Link to this sectionExportar 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 nueva generación y el nuevo nombre de TensorFlow Lite (TFLite), y ejecuta el mismo formato de modelo .tflite. Con LiteRT, un único modelo de Ultralytics YOLO exportado se despliega en dispositivos móviles, embebidos, edge y navegadores, cubriendo todo lo que los antiguos formatos de exportación tflite y tfjs gestionaban por separado, ahora bajo una misma solución.

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 de forma rápida y sin conexión en una amplia gama de dispositivos.

Link to this section¿Por qué deberías exportar a LiteRT?#

LiteRT es un framework de código abierto diseñado para la inferencia en dispositivos, también conocido como edge computing. Proporciona a los desarrolladores las herramientas necesarias para ejecutar modelos entrenados en dispositivos móviles, embebidos e 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 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, eliminando la necesidad de una exportación separada a TensorFlow.js.

Link to this sectionCaracterí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: Soporta FP32, INT8 estático (quantize=8, pesos int8 + activaciones int8), activación INT16 estática (quantize="w8a16", pesos int8 + activaciones int16 para 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 de precisión mínima.
• Soporte para diversos lenguajes: Compatible con Java/Kotlin, Swift, Objective-C, C++, Python y JavaScript.

Link to this sectionExportar 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.

Link to this sectionInstalación#

Para instalar el paquete necesario, ejecuta:

# Install the required package for YOLO
pip install ultralytics

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

Link to this sectionUso#

Todos los modelos YOLO de Ultralytics soportan la exportación desde el primer momento. El formato LiteRT soporta los modos Export, Predict y Validate, por lo que puedes exportar un modelo, cargarlo para ejecutar inferencia 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")  # creates 'yolo26n.tflite'

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Dynamic INT8: int8 weights, FP32 activations - no calibration data needed
model.export(format="litert", quantize="w8a32")  # creates 'yolo26n_w8a32.tflite'

# Static INT8: int8 weights + int8 activations - needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8.tflite'

# Static w8a16: int8 weights + int16 activations (higher accuracy) - needs calibration data
model.export(format="litert", quantize="w8a16", data="coco8.yaml")  # creates 'yolo26n_w8a16.tflite'

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")

Link to this sectionArgumentos de exportación#

Para obtener más detalles sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre la exportación.

Link to this sectionDesplegar modelos YOLO LiteRT exportados#

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

Link to this sectionMóvil y Embebidos#

• Android: Una guía de inicio rápido para integrar LiteRT en aplicaciones Android.
• iOS: Una guía para integrar y desplegar modelos LiteRT en aplicaciones iOS.
• Embedded Linux y Raspberry Pi: Ejecuta modelos LiteRT en ordenadores monoplaca, opcionalmente acelerados con un Coral Edge TPU.
• Microcontroladores: Despliega en MCUs con solo unos pocos kilobytes de memoria; el runtime principal ocupa aproximadamente 16 KB en un Arm Cortex-M3.

Link to this sectionNavegador y Node.js (LiteRT.js)#

• Resumen de LiteRT.js: Ejecuta el mismo modelo .tflite directamente en el navegador con aceleración WebGPU/WASM, eliminando la computación del lado del servidor y manteniendo los datos en el dispositivo del usuario.
• Ejemplos integrales: Ejemplos prácticos y tutoriales para implementar LiteRT en móviles, edge y web.

Link to this sectionResumen#

En esta guía, cubrimos cómo exportar modelos YOLO de Ultralytics al formato LiteRT. Al consolidar el despliegue en móvil/edge (antes TFLite) y 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 destino en el dispositivo.

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

Además, si tienes curiosidad sobre otras integraciones de Ultralytics YOLO, consulta nuestra página de guías de integración para acceder a muchos recursos útiles.

Link to this sectionFAQ#

Link to this section¿Cómo exporto un modelo YOLO al formato LiteRT?#

Usa la librería 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")  # creates 'yolo26n.tflite'

Para usuarios de CLI:

yolo export model=yolo26n.pt format=litert # creates 'yolo26n.tflite'

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

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

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

• El antiguo formato tflite → despliegue en móviles, dispositivos embebidos y edge.
• El antiguo formato tfjs → despliegue en navegador y Node.js, ahora gestionado 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.

Link to this section¿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 la velocidad de inferencia. Para mayor optimización, considera usar una Coral Edge TPU. Para pasos detallados, consulta nuestra guía de despliegue en Raspberry Pi.

Link to this section¿Puedo ejecutar modelos YOLO en el navegador con LiteRT?#

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

Link to this section¿Soporta LiteRT inferencia en FP16 (media precisión)?#

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

Link to this section¿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.
• Comprobar compatibilidad del paquete: Asegúrate de estar usando una versión compatible de Ultralytics. Consulta nuestra guía de instalación.
• Problemas de cuantificación: Cuando uses cuantificación INT8, asegúrate de que la ruta de tu conjunto de datos esté correctamente especificada en el parámetro data.

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