Link to this sectionExportación de modelos TFLite para despliegue (obsoleto)#

Desplegar modelos de computer vision en dispositivos de borde o integrados requiere un formato que pueda garantizar un rendimiento fluido.

El antiguo formato de exportación TensorFlow Lite o TFLite optimizaba los modelos Ultralytics YOLO26 para tareas como la detección de objetos y la clasificación de imágenes en aplicaciones de borde. Esta guía conserva el contexto de despliegue heredado de TFLite; utiliza LiteRT para nuevas exportaciones.

Link to this section¿Por qué se utilizaba TFLite para la exportación?#

Introducido por Google en mayo de 2017 como parte de su framework TensorFlow, TensorFlow Lite, o TFLite para abreviar, fue un framework de aprendizaje profundo de código abierto diseñado para la inferencia en el dispositivo, también conocido como edge computing. Proporcionaba a los desarrolladores herramientas para ejecutar modelos entrenados en dispositivos móviles, integrados e IoT, así como en equipos informáticos tradicionales.

TensorFlow Lite admitía una amplia gama de plataformas, incluyendo Linux embebido, Android, iOS y microcontroladores (MCUs). Las exportaciones TFLite permitían a las aplicaciones ejecutar modelos de forma local y sin conexión.

Link to this sectionCaracterísticas clave de los modelos TFLite#

Los modelos TFLite ofrecen una amplia gama de características clave que permiten el aprendizaje automático en el dispositivo, ayudando a los desarrolladores a ejecutar sus modelos en dispositivos móviles, integrados y de borde:

• Optimización en el dispositivo: TFLite se optimiza para ML en el dispositivo, reduciendo la latencia al procesar datos localmente, mejorando la privacidad al no transmitir datos personales y minimizando el tamaño del modelo para ahorrar espacio.

• Soporte para múltiples plataformas: TFLite ofrece una amplia compatibilidad de plataformas, soportando Android, iOS, Linux integrado y microcontroladores.

• Soporte para diversos lenguajes: TFLite es compatible con varios lenguajes de programación, incluyendo Java, Swift, Objective-C, C++ y Python.

• Alto rendimiento: Logra un rendimiento superior mediante la aceleración de hardware y la optimización del modelo.

Link to this sectionRendimiento medido (histórico)#

Comparativa antes/después por tarea en la GPU Adreno de un Xiaomi 17 (Qualcomm Snapdragon 8 Elite Gen 5, SM8850), medida a través del plugin de Flutter de Ultralytics 0.6.8: los activos heredados de INT8 TFLite de onnx2tf (NHWC, entrada images) frente a los nuevos activos de w8a32 LiteRT (NCHW, entrada args_0), ambos ejecutados en LiteRT 2.x en la misma prueba consecutiva con el imgsz de Android suministrado. Cada celda es el tiempo total (preprocesamiento + inferencia + posprocesamiento) con el desglose por etapa debajo; ambos formatos se compilaron completamente en la GPU.

El formato w8a32 LiteRT iguala o supera al formato heredado INT8 de onnx2tf en cinco de las seis tareas en cuanto a latencia total. Semantic sigue siendo la regresión de formato porque los logits NCHW de w8a32 requieren más tiempo de inferencia que los logits NHWC heredados, incluso después de limpiar el preprocesamiento. Los modelos heredados de onnx2tf se ejecutan sin cambios en LiteRT 2.x junto con las nuevas exportaciones NCHW. Los activos oficiales de Android LiteRT están alojados en la versión v0.6.6 de yolo-flutter-app, con el registro detallado de rendimiento en el documento de rendimiento de Flutter.

Link to this sectionRegresiones de formato frente a LiteRT#

Detección con YOLO26n en el mismo dispositivo en la GPU Adreno de un Xiaomi 17: TFLite INT8 heredado de onnx2tf frente a los cuatro formatos de cuantización de LiteRT, todo medido en una ejecución sostenida (por lo que la inferencia es la métrica comparable dependiente del formato):

Problemas para el equipo de Google LiteRT / litert-torch, detectados al migrar activos de producción de Android desde onnx2tf TFLite a LiteRT:

1. El diseño NCHW hace que los consumidores sean conscientes del diseño. litert-torch rastrea el modelo de PyTorch y emite NCHW [1,3,H,W] con una entrada flotante, mientras que la exportación TFLite de onnx2tf era NHWC [1,H,W,3], lo que coincide con el diseño de cámara/mapa de bits. El plugin actual de Flutter escribe CHW planar directamente durante el empaquetado RGB, evitando una transposición HWC→CHW por separado, pero los consumidores más simples aún necesitan un empaquetado planar directo o una transposición adicional.
2. quantize="w8a16" no se compila en el delegado de GPU (OpenCL) y recurre silenciosamente a una ruta de CPU que es ~40 veces más lenta (~660 ms frente a ~17 ms), lo que hace que el formato de activación int16 sea inutilizable para el despliegue en GPU.
3. El INT8 estático (quantize=8) es el formato de GPU más lento — ~11 ms frente a ~8.6 ms del modelo INT8 de onnx2tf heredado equivalente, es decir, la propia ruta INT8 de LiteRT presenta una regresión respecto al formato al que reemplazó. El rango dinámico w8a32 es el único formato de LiteRT que iguala la velocidad del antiguo INT8, razón por la cual es el que se distribuye ahora.
4. Los modelos de segmentación (semantic) se exportan como logits NCHW sin procesar sin opción de ArgMax en el grafo, lo que obliga a realizar un argmax del lado del host que no es eficiente para la caché sobre [1, C, H, W] (cada plano de clase está a una distancia completa de H×W). Las rutas de onnx2tf, CoreML y QNN pueden emitir un mapa de clases compacto en su lugar.
5. Los tensores de salida fueron renombrados a output_0, output_1, … (frente a Identity, Identity_1, … de onnx2tf), lo cual rompió silenciosamente la búsqueda de la forma de salida en tiempo de ejecución hasta que el consumidor añadió los nuevos nombres.

Los números correspondientes de LiteRT w8a32 (el formato que se distribuye actualmente) están en la página de LiteRT.

Link to this sectionOpciones de despliegue en TFLite#

Antes de ver el ejemplo de exportación de reemplazo con LiteRT, comprendamos cómo se utilizan normalmente los modelos TFLite.

TFLite ofrece varias opciones de despliegue en el dispositivo para modelos de aprendizaje automático, incluyendo:

• Despliegue con Android e iOS: Tanto las aplicaciones de Android como las de iOS con TFLite pueden analizar transmisiones de cámaras y sensores de borde para detectar e identificar objetos. TFLite también ofrece bibliotecas nativas para iOS escritas en Swift y Objective-C. El diagrama de arquitectura a continuación muestra el proceso de desplegar un modelo entrenado en plataformas Android e iOS usando TensorFlow Lite.

• Implementación con Linux integrado: Si la ejecución de inferencias en una Raspberry Pi usando la Guía de Ultralytics no cumple con los requisitos de velocidad para tu caso de uso, puedes usar un modelo TFLite exportado para acelerar los tiempos de inferencia. Además, es posible mejorar aún más el rendimiento utilizando un dispositivo Coral Edge TPU.

• Despliegue con microcontroladores: Los modelos TFLite también pueden desplegarse en microcontroladores y otros dispositivos con solo unos pocos kilobytes de memoria. El núcleo de ejecución cabe en solo 16 KB en un Arm Cortex M3 y puede ejecutar muchos modelos básicos. No requiere soporte de sistema operativo, ninguna biblioteca estándar de C o C++ ni asignación de memoria dinámica.

Link to this sectionReemplaza la exportación TFLite con LiteRT#

Para nuevas exportaciones, convierte tu modelo a LiteRT. El modelo resultante mantiene la extensión de archivo .tflite.

Link to this sectionInstalación#

Para instalar los paquetes necesarios, ejecuta:

# Install the required package for YOLO26
pip install ultralytics

Para instrucciones detalladas y mejores prácticas relacionadas con el proceso de instalación, consulta nuestra Guía de instalación de Ultralytics. Mientras instalas los paquetes requeridos para YOLO26, si encuentras alguna dificultad, consulta nuestra Guía de problemas comunes para obtener soluciones y consejos.

Link to this sectionUso#

Todos los modelos de Ultralytics YOLO26 están diseñados para admitir la exportación desde el primer momento, facilitando su integración en tu flujo de trabajo de despliegue preferido. Puedes ver la lista completa de formatos de exportación admitidos y las opciones de configuración para elegir la mejor configuración para tu aplicación.

El formato de reemplazo LiteRT admite los modos Export, Predict y Validate. Exporta tu modelo y luego carga el modelo .tflite exportado para ejecutar la inferencia o validar su precisión.

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

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

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

from ultralytics import YOLO

# Load the exported TFLite 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 sectionDesplegando modelos YOLO26 TFLite exportados#

Después de exportar tu modelo Ultralytics YOLO26 al formato LiteRT, puedes desplegar el modelo .tflite resultante. El primer paso principal y recomendado para ejecutar un modelo TFLite es utilizar el método YOLO("model.tflite"), tal como se describe en el fragmento de código de uso anterior. Sin embargo, para obtener instrucciones detalladas sobre cómo desplegar tus modelos TFLite en otros entornos, echa un vistazo a los siguientes recursos:

• Android: Una guía de inicio rápido para integrar TensorFlow Lite en aplicaciones Android, que proporciona pasos fáciles de seguir para configurar y ejecutar modelos de machine learning.

• iOS: Consulta esta guía detallada para desarrolladores sobre cómo integrar y desplegar modelos TensorFlow Lite en aplicaciones iOS, ofreciendo instrucciones paso a paso y recursos.

• Ejemplos integrales: Esta página ofrece una visión general de varios ejemplos de TensorFlow Lite, mostrando aplicaciones prácticas y tutoriales diseñados para ayudar a los desarrolladores a implementar TensorFlow Lite en sus proyectos de aprendizaje automático en dispositivos móviles y de borde.

Link to this sectionResumen#

Esta guía conserva el flujo de trabajo de despliegue heredado de TFLite. Para nuevas exportaciones, utiliza LiteRT para crear modelos .tflite para entornos de edge computing.

Para más detalles sobre su uso, visita la documentación oficial de TFLite.

Además, si tienes curiosidad sobre otras integraciones de Ultralytics YOLO26, echa un vistazo a nuestra página de guía de integración. Encontrarás mucha información útil y perspectivas allí.

Link to this sectionFAQ#

Link to this section¿Cómo reemplazo una exportación TFLite con LiteRT?#

Para una nueva exportación, utiliza el formato LiteRT. Primero, instala el paquete necesario usando:

pip install ultralytics

Luego, usa el siguiente fragmento de código para exportar 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, puedes lograr esto con:

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áles son los beneficios de usar TensorFlow Lite para el despliegue de modelos YOLO26?#

TensorFlow Lite (TFLite) es un marco de deep learning de código abierto diseñado para la inferencia en el dispositivo, lo que lo hace ideal para desplegar modelos YOLO26 en dispositivos móviles, integrados e IoT. Los beneficios clave incluyen:

• Optimización en el dispositivo: Minimiza la latencia y mejora la privacidad procesando los datos localmente.
• Compatibilidad de plataforma: Soporta Android, iOS, Linux integrado y MCU.
• Rendimiento: Utiliza aceleración de hardware para optimizar la velocidad y eficiencia del modelo.

Para aprender más, consulta la guía de TFLite.

Link to this section¿Es posible ejecutar modelos YOLO26 TFLite en Raspberry Pi?#

Sí, puedes ejecutar modelos TFLite de YOLO26 en Raspberry Pi para mejorar la velocidad de inferencia. Primero, exporta tu modelo al formato LiteRT como se explicó anteriormente. Luego, utiliza una herramienta como TensorFlow Lite Interpreter para ejecutar el modelo en tu Raspberry Pi.

Para optimizaciones adicionales, podrías considerar usar Coral Edge TPU. Para pasos detallados, consulta nuestra guía de despliegue en Raspberry Pi y la guía de integración de Edge TPU.

Link to this section¿Puedo usar modelos TFLite en microcontroladores para predicciones con YOLO26?#

Sí, TFLite soporta el despliegue en microcontroladores con recursos limitados. El núcleo de ejecución de TFLite requiere solo 16 KB de memoria en un Arm Cortex M3 y puede ejecutar modelos YOLO26 básicos. Esto lo hace adecuado para su despliegue en dispositivos con potencia computacional y memoria mínimas.

Para empezar, visita la guía de TFLite Micro para microcontroladores.

Link to this section¿Qué plataformas son compatibles con los modelos YOLO26 exportados a TFLite?#

TensorFlow Lite proporciona una amplia compatibilidad de plataformas, permitiéndote desplegar modelos YOLO26 en una amplia gama de dispositivos, incluyendo:

• Android e iOS: Soporte nativo a través de las bibliotecas de TFLite para Android e iOS.
• Linux integrado: Ideal para computadoras de placa única como Raspberry Pi.
• Microcontroladores: Adecuado para MCUs con recursos limitados.

Para más información sobre las opciones de despliegue, consulta nuestra guía de despliegue detallada.

Link to this section¿Cómo soluciono problemas comunes durante la exportación de modelos YOLO26 a LiteRT?#

Si encuentras errores mientras exportas modelos YOLO26 a LiteRT, las soluciones comunes incluyen:

• Comprueba la compatibilidad de paquetes: Asegúrate de estar utilizando versiones compatibles de Ultralytics, litert-torch y ai-edge-litert. Consulta nuestra guía de instalación.
• Soporte de modelos: Verifica que el modelo YOLO26 específico admita la exportación a LiteRT consultando la página de documentación de exportación de Ultralytics.
• 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.