Exportar modelos YOLO a LiteRT para despliegue en Edge y Web#

LiteRT (abreviatura de Lite Runtime) es el entorno de ejecución de alto rendimiento de Google para IA en dispositivos. Es la próxima generación y el nuevo nombre de TensorFlow Lite (TFLite), y ejecuta el mismo formato de modelo .tflite. Con LiteRT, un único modelo exportado de Ultralytics YOLO se implementa en dispositivos móviles, integrados, de borde y en el navegador, abarcando todo lo que los formatos de exportación anteriores tflite y tfjs gestionaban por separado, ahora bajo un mismo paraguas.

El formato de exportación LiteRT optimiza tus modelos para tareas como detección de objetos, segmentación, estimación de poses y clasificación para que se ejecuten rápido y sin conexión en una amplia gama de dispositivos.

npm i @ultralytics/yolo @litertjs/core

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

LiteRT es un marco de código abierto diseñado para la inferencia en dispositivos, también conocido como computación de borde. Ofrece a los desarrolladores las herramientas para ejecutar modelos entrenados en dispositivos móviles, integrados y de IoT, ordenadores tradicionales y —a través de LiteRT.js— directamente en navegadores web y Node.js.

Un formato de modelo, cualquier destino:

• Móvil y Embebidos: Android, iOS, Linux embebido y microcontroladores (MCUs).
• Aceleradores de borde: Compatible con Coral Edge TPU para una mayor aceleración.
• Navegador y Node.js: LiteRT.js ejecuta el mismo modelo .tflite en la web con aceleración WebGPU/WASM, eliminando la necesidad de una exportación separada para TensorFlow.js.

Características clave de los modelos LiteRT#

• Optimización en el dispositivo: Reduce la latencia al procesar datos localmente, mejora la privacidad al no transmitir datos personales y minimiza el tamaño del modelo para ahorrar espacio.
• Soporte multiplataforma: Funciona en Android, iOS, Linux embebido, microcontroladores y navegadores web modernos.
• Aceleración por hardware: Aprovecha XNNPACK en CPU y aceleración por GPU mediante OpenCL, Metal y WebGPU. El delegado de GPU se ejecuta en FP16 por defecto para mayor velocidad.
• Cuantización: Es compatible con FP32, INT8 estático (quantize=8, pesos INT8 + activaciones INT8), activación INT8 estática (quantize="w8a16", pesos INT8 + activaciones INT16 para mayor precisión) y 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.
• Soporte para 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 de una sola imagen: la media de 15 ejecuciones tras 3 ejecuciones de calentamiento en bus.jpg, medida con el complemento de Flutter para Ultralytics 0.6.10 y los recursos estandarizados v0.6.6. El orden de CPU/GPU se alternó entre tareas en un barrido secuencial. Los registros nativos confirmaron que cada fila de CPU utilizó LiteRT CPU/XNNPACK y cada fila de GPU delegó el gráfico completo en LiteRT OpenCL (LITERT_CL).
• La exportación de LiteRT rastrea el modelo de PyTorch directamente, produciendo un archivo .tflite en formato NCHW con una entrada de tipo float; el delegado de GPU compila todo el gráfico (las siete tareas se ejecutan aquí en la GPU Adreno) y w8a32 no requiere datos de calibración. Los consumidores deben leer las formas de los tensores y los nombres de las firmas en lugar de asumir el diseño heredado NHWC de onnx2tf o los nombres de salida de Identity; empaqueta los datos RGB directamente como CHW planar o transpónelos antes de la inferencia. Las exportaciones semánticas devuelven logits en formato NCHW y requieren un argmax de clase en el lado del host. Los recursos oficiales para Android se alojan en la versión v0.6.6 de yolo-flutter-app, con el registro de rendimiento detallado en la documentación de rendimiento de Flutter.
• Los números correspondientes a la NPU Hexagon de Snapdragon y a la CPU/GPU de LiteRT se encuentran en la integración con Qualcomm QNN.
• Compara los resultados de la CPU/acelerador de Apple en la integración con CoreML.

Los siguientes barridos de dispositivos utilizan los mismos recursos estandarizados de 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 serie D y TPU de Google. Las frecuencias de reloj del núcleo y el nombre del controlador de la GPU se leyeron del dispositivo de referencia porque Google no los publica en las especificaciones enlazadas.

Evaluación comparativa: Media de 15 llamadas a predict() tras 3 calentamientos en bus.jpg, utilizando ultralytics_yolo 0.6.10 y los recursos oficiales de v0.6.6. El orden de CPU/GPU se alterna entre tareas en un barrido secuencial. Los registros nativos confirmaron que cada fila de CPU usó LiteRT CPU/XNNPACK y cada fila de GPU delegó el gráfico 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.

Evaluación comparativa: Media de 15 llamadas a predict() tras 3 calentamientos en bus.jpg, utilizando ultralytics_yolo 0.6.10 y los recursos oficiales de v0.6.6. El orden de CPU/GPU se alterna entre tareas en un barrido secuencial. Los registros nativos confirmaron que cada fila de CPU usó LiteRT CPU/XNNPACK y cada fila de GPU delegó el gráfico 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 (MT6993) de 3 nm 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 2.7 GHz), GPU Mali-G1 Ultra MC12 y MediaTek NPU 990.

Evaluación comparativa: Media de 15 llamadas a predict() tras 3 calentamientos en bus.jpg, utilizando ultralytics_yolo 0.6.10 y los recursos oficiales de v0.6.6. El orden de CPU/GPU se alterna entre tareas en un barrido secuencial. Los registros nativos confirmaron que cada fila de CPU usó LiteRT CPU/XNNPACK y cada fila de GPU delegó el gráfico 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 esas cabezas.

Exportar 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 obtener instrucciones detalladas y mejores prácticas, consulta nuestra guía de instalación de Ultralytics. Si encuentras alguna dificultad, consulta nuestra guía de problemas comunes.

Uso#

Todos los modelos de Ultralytics YOLO admiten la exportación de forma nativa. El formato LiteRT es compatible con los modos Export, Predict y Validate, por lo que puedes exportar un modelo y luego cargarlo 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 más detalles sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.

Desplegar modelos YOLO LiteRT exportados#

Después de exportar tu modelo de 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") que se muestra arriba. Para la implementación en otros entornos, consulta los siguientes recursos:

Móvil y Embebidos#

• Android: Una guía de inicio rápido para integrar LiteRT en aplicaciones de Android.
• iOS: Una guía para integrar e implementar modelos de LiteRT en aplicaciones de iOS.
• Linux integrado y Raspberry Pi: Ejecuta modelos de LiteRT en ordenadores de placa única, opcionalmente acelerados con una 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 la computación en el lado del servidor y manteniendo los datos en el dispositivo del usuario.
• Ejemplos de extremo a extremo: Ejemplos prácticos y tutoriales para implementar LiteRT en dispositivos móviles, de borde y en la web.

Resumen#

En esta guía, hemos explicado cómo exportar modelos de Ultralytics YOLO al formato LiteRT. Al consolidar la implementación móvil y de borde (anteriormente TFLite) y en el navegador (anteriormente TF.js) en un único modelo .tflite, LiteRT hace que tus modelos YOLO sean más rápidos, más pequeños y portátiles en prácticamente cualquier destino en el dispositivo.

Para obtener más detalles, 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 integración para encontrar una gran variedad de recursos útiles.

FAQ#

¿Cómo exporto un modelo YOLO al formato LiteRT?#

Usa la biblioteca de Ultralytics para exportar un modelo YOLO a LiteRT (.tflite). Primero, instala el paquete:

pip install ultralytics

Luego, exporta tu modelo:

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

Para usuarios de CLI:

yolo export model=yolo26n.pt format=litert imgsz=640 # use imgsz=224 for classification

Para obtener más detalles, visita la guía de exportación de Ultralytics.

¿Cuál es la diferencia entre LiteRT, TFLite y TF.js?#

LiteRT es el nuevo nombre de TensorFlow Lite: el mismo formato de modelo .tflite, la misma línea de entornos de ejecución, renombrado por Google. En Ultralytics, el único formato de exportación litert ahora cubre ambos casos de uso que antes requerían dos formatos separados:

• El antiguo formato tflite → implementación móvil, integrada y de borde.
• El antiguo formato tfjs → implementación en navegador y Node.js, gestionada ahora por LiteRT.js ejecutando el mismo archivo .tflite.

Si tienes un archivo .tflite existente, puedes cargarlo directamente con YOLO("model.tflite") y se ejecutará a través del backend de LiteRT.

¿Puedo ejecutar modelos YOLO LiteRT en una Raspberry Pi?#

Sí. Exporta tu modelo al formato LiteRT y luego ejecútalo en una Raspberry Pi para mejorar las velocidades de inferencia. Para una optimización adicional, considera una Coral Edge TPU. Para conocer los pasos detallados, consulta nuestra guía de implementación en Raspberry Pi.

¿Puedo ejecutar modelos YOLO en el navegador con LiteRT?#

Sí. LiteRT.js ejecuta el mismo modelo exportado .tflite directamente en un navegador web o aplicación de Node.js, con aceleración WebGPU/WASM. Esto reemplaza el flujo de trabajo anterior de TensorFlow.js; no hay ninguna exportación separada para el navegador, simplemente implementa tu modelo LiteRT con el entorno de ejecución de LiteRT.js.

¿Soporta LiteRT inferencia en FP16 (media precisión)?#

Sí, en tiempo de ejecución. Un modelo LiteRT en FP32 se ejecuta automáticamente en FP16 cuando se ejecuta en un delegado de GPU (WebGPU, OpenCL o Metal), que es el enfoque oficial de LiteRT. Por lo tanto, no necesitas una exportación dedicada en FP16; para una mayor compresión, utiliza la cuantización INT8 con quantize=8.

¿Cómo soluciono problemas comunes durante la exportación a LiteRT?#

Si encuentras errores al exportar modelos YOLO a LiteRT, algunas soluciones comunes son:

• Comprobar plataforma: La exportación a LiteRT es compatible con Linux x86_64 y macOS. Verifica que tu entorno coincida.
• Verificar la compatibilidad del paquete: Asegúrate de estar usando una versión compatible de Ultralytics. Consulta nuestra guía de instalación.
• Problemas de cuantización: Al utilizar la cuantización INT8, asegúrate de que la ruta de tu conjunto de datos esté especificada correctamente en el parámetro data.

Para obtener consejos adicionales de solución de problemas, visita nuestra guía de problemas comunes.