Exporta modelos YOLO a LiteRT para el despliegue en dispositivos edge y la web#

LiteRT (abreviatura de Lite Runtime) es el runtime 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 despliega en móviles, dispositivos integrados, dispositivos edge y el navegador, cubriendo todo lo que los antiguos formatos de exportación tflite y tfjs gestionaban por separado, ahora bajo un mismo paraguas.

El formato de exportación de 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 rápidamente y sin conexión en una amplia variedad de dispositivos.

npm i @ultralytics/yolo @litertjs/core

¿Por qué deberías exportar a LiteRT?#

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

Un formato de modelo, todos los destinos:

• Móviles y dispositivos integrados: Android, iOS, Linux integrado y microcontroladores (MCU).
• Aceleradores edge: Compatible con Coral Edge TPU para una aceleración adicional.
• Navegador y Node.js: LiteRT.js ejecuta el mismo modelo .tflite en la web con aceleración WebGPU/WASM, lo que elimina la necesidad de una exportación independiente a TensorFlow.js.

Características principales 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: Se ejecuta en Android, iOS, Linux integrado, microcontroladores y navegadores web modernos.
• Aceleración de hardware: Aprovecha XNNPACK en la CPU y la aceleración de GPU mediante OpenCL, Metal y WebGPU. El delegado de GPU se ejecuta en FP16 de forma predeterminada para obtener más velocidad.
• Cuantización: Admite FP32, INT8 estático (quantize=8, pesos int8 + activaciones int8), activación INT16 estática (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 los 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) tiene 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 0.6.10 del plugin de Ultralytics para Flutter y los recursos estandarizados v0.6.6. El orden CPU/GPU se alternó entre tareas en un único recorrido 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 de PyTorch y produce un .tflite NCHW con una entrada float; el delegado de GPU compila el grafo completo (aquí, las siete tareas se ejecutan en la GPU Adreno), y w8a32 no necesita datos de calibración. Los consumidores deben leer las formas de los tensores y los nombres de las firmas en lugar de asumir la disposición NHWC heredada de onnx2tf o los nombres de salida Identity; empaqueta los datos RGB directamente como CHW planar o transpónlos antes de la inferencia. Las exportaciones semánticas devuelven logits NCHW y requieren un argmax de clase en el lado del host. Los recursos oficiales para Android están alojados en la versión v0.6.6 de yolo-flutter-app, con el registro detallado del benchmark en la documentación de rendimiento de Flutter.
• Los resultados de la NPU Hexagon de Snapdragon correspondiente y las cifras de CPU/GPU de LiteRT se encuentran en la integración de Qualcomm QNN.
• Compara los resultados de CPU/acelerador de Apple en la integración de CoreML.

Los siguientes barridos de 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 la GPU se obtuvieron del dispositivo del benchmark porque Google no los publica en las especificaciones enlazadas.

Benchmark: Media de 15 llamadas predict() después de 3 calentamientos en bus.jpg, usando ultralytics_yolo, 0.6.10 y los recursos oficiales v0.6.6. El orden CPU/GPU se alterna entre tareas en un único recorrido 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).

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 rendimiento de hasta 3,26 GHz y 6 núcleos C1-Pro de eficiencia de hasta 2,76 GHz), GPU Xclipse 960 y NPU de Samsung.

Benchmark: Media de 15 llamadas predict() después de 3 calentamientos en bus.jpg, usando ultralytics_yolo, 0.6.10 y los recursos oficiales v0.6.6. El orden CPU/GPU se alterna entre tareas en un único recorrido 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).

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.

Benchmark: Media de 15 llamadas predict() después de 3 calentamientos en bus.jpg, usando ultralytics_yolo, 0.6.10 y los recursos oficiales v0.6.6. El orden CPU/GPU se alterna entre tareas en un único recorrido 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).

Tareas compatibles#

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

Exporta a LiteRT: convierte tu modelo YOLO#

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

Instalación#

Para instalar el paquete necesario, ejecuta:

# Install the required package for YOLO
pip install ultralytics

Para consultar instrucciones detalladas y prácticas recomendadas, visita nuestra guía de instalación de Ultralytics. Si encuentras alguna dificultad, consulta nuestra guía de problemas habituales.

Uso#

Todos los modelos Ultralytics YOLO admiten la exportación directamente. El formato LiteRT admite los modos Export, Predict y Validate, por lo que puedes exportar un modelo y cargarlo después para ejecutar inferencias o validar su precisión localmente.

from ultralytics import YOLO

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

# Export the model to LiteRT format
model.export(format="litert", imgsz=640)  # use imgsz=224 for classification

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32", imgsz=640)  # use imgsz=224 for classification

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml", imgsz=640)  # use 224 for classification

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml", imgsz=640)  # use 224 for classification

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

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

from ultralytics import YOLO

# Load the exported LiteRT model
model = YOLO("yolo26n.tflite")

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

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 verificarlo localmente es el método YOLO("yolo26n.tflite") mostrado arriba. Para implementarlo en otros entornos, consulta los siguientes recursos:

Móviles y dispositivos integrados#

• Android: Guía de inicio rápido para integrar LiteRT en aplicaciones Android.
• iOS: Guía para integrar e implementar modelos LiteRT en aplicaciones iOS.
• Linux integrado y Raspberry Pi: Ejecuta modelos LiteRT en ordenadores de placa única, con aceleración opcional mediante un Coral Edge TPU.
• Microcontroladores: Implementa 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 el procesamiento en el servidor y manteniendo los datos en el dispositivo del usuario.
• Ejemplos de principio a fin: Ejemplos prácticos y tutoriales para implementar LiteRT en dispositivos móviles, edge y la web.

Resumen#

En esta guía, hemos explicado cómo exportar modelos Ultralytics YOLO al formato LiteRT. Al consolidar la implementación en dispositivos móviles/edge (antes TFLite) y en el navegador (antes TF.js) en un único modelo .tflite, LiteRT hace que tus modelos YOLO sean más rápidos, pequeños 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 la guía de integraciones, donde encontrarás muchos recursos útiles.

Preguntas frecuentes#