Despliega YOLO26 en móviles y dispositivos Edge con ExecuTorch

Desplegar modelos de visión artificial en dispositivos edge como smartphones, tablets y sistemas embebidos requiere un entorno de ejecución optimizado que equilibre el rendimiento con las restricciones de recursos. ExecuTorch, la solución de PyTorch para computación edge, permite una inferencia eficiente en el dispositivo para modelos de Ultralytics YOLO.

Esta guía detalla cómo exportar modelos Ultralytics YOLO al formato ExecuTorch, lo que te permite desplegar tus modelos en dispositivos móviles y edge con un rendimiento optimizado.

¿Por qué exportar a ExecuTorch?

ExecuTorch es la solución integral de PyTorch para habilitar capacidades de inferencia en el dispositivo a través de móviles y dispositivos edge. Construido con el objetivo de ser portátil y eficiente, ExecuTorch puede utilizarse para ejecutar programas de PyTorch en una amplia variedad de plataformas informáticas.

Características clave de ExecuTorch

ExecuTorch proporciona varias características potentes para desplegar modelos Ultralytics YOLO en dispositivos edge:

• Formato de modelo portátil: ExecuTorch utiliza el formato .pte (PyTorch ExecuTorch), que está optimizado en tamaño y velocidad de carga para dispositivos con recursos limitados.

• Backend XNNPACK: La integración predeterminada con XNNPACK proporciona una inferencia altamente optimizada en CPUs móviles, ofreciendo un excelente rendimiento sin necesidad de hardware especializado.

• Soporte de cuantización: Soporte integrado para técnicas de cuantización que reducen el tamaño del modelo y mejoran la velocidad de inferencia manteniendo la precisión.

• Eficiencia de memoria: La gestión optimizada de la memoria reduce el consumo de memoria en tiempo de ejecución, haciéndolo adecuado para dispositivos con RAM limitada.

• Metadatos del modelo: Los modelos exportados incluyen metadatos (tamaño de imagen, nombres de clases, etc.) en un archivo YAML separado para una fácil integración.

Opciones de despliegue con ExecuTorch

Los modelos de ExecuTorch pueden desplegarse en diversas plataformas móviles y edge:

• Aplicaciones móviles: Despliega en aplicaciones iOS y Android con rendimiento nativo, habilitando la detección de objetos en tiempo real en apps móviles.

• Sistemas embebidos: Ejecuta en dispositivos Linux embebidos como Raspberry Pi, NVIDIA Jetson y otros sistemas basados en ARM con rendimiento optimizado.

• Dispositivos Edge AI: Despliega en hardware de IA especializado en edge con delegados personalizados para una inferencia acelerada.

• Dispositivos IoT: Integra en dispositivos IoT para inferencia en el dispositivo sin necesidad de conexión a la nube.

Exportación de modelos Ultralytics YOLO26 a ExecuTorch

Convertir modelos Ultralytics YOLO26 al formato ExecuTorch permite un despliegue eficiente en dispositivos móviles y edge.

Instalación

La exportación a ExecuTorch requiere Python 3.10 o superior y dependencias específicas:

# Install Ultralytics package
pip install ultralytics

Para obtener instrucciones detalladas y las mejores prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalación de YOLO26. Si encuentras alguna dificultad al instalar los paquetes necesarios para YOLO26, consulta nuestra guía de problemas comunes para ver soluciones y consejos.

Uso

Exportar modelos YOLO26 a ExecuTorch es sencillo:

from ultralytics import YOLO

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

# Export the model to ExecuTorch format
model.export(format="executorch")  # creates 'yolo26n_executorch_model' directory

# Load the exported ExecuTorch model
executorch_model = YOLO("yolo26n_executorch_model")

# Run inference on a single image
results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

Argumentos de exportación

Al exportar al formato ExecuTorch, puedes especificar los siguientes argumentos:

Estructura de salida

La exportación a ExecuTorch crea un directorio que contiene el modelo y los metadatos:

yolo26n_executorch_model/
├── yolo26n.pte              # ExecuTorch model file
└── metadata.yaml            # Model metadata (classes, image size, etc.)

Uso de modelos exportados de ExecuTorch

Después de exportar tu modelo, tendrás que integrarlo en tu aplicación objetivo utilizando el runtime de ExecuTorch.

Integración móvil

Para aplicaciones móviles (iOS/Android), deberás:

1. Añadir el runtime de ExecuTorch: Incluye la biblioteca del runtime de ExecuTorch en tu proyecto móvil
2. Cargar el modelo: Carga el archivo .pte en tu aplicación
3. Ejecutar inferencia: Procesa imágenes y obtén predicciones

Ejemplo de integración en iOS (Objective-C/C++):

// iOS uses C++ APIs for model loading and inference
// See https://pytorch.org/executorch/stable/using-executorch-ios.html for complete examples

#include <executorch/extension/module/module.h>

using namespace ::executorch::extension;

// Load the model
Module module("/path/to/yolo26n.pte");

// Create input tensor
float input[1 * 3 * 640 * 640];
auto tensor = from_blob(input, {1, 3, 640, 640});

// Run inference
const auto result = module.forward(tensor);

Ejemplo de integración en Android (Kotlin):

import org.pytorch.executorch.EValue
import org.pytorch.executorch.Module
import org.pytorch.executorch.Tensor

// Load the model
val module = Module.load("/path/to/yolo26n.pte")

// Prepare input tensor
val inputTensor = Tensor.fromBlob(floatData, longArrayOf(1, 3, 640, 640))
val inputEValue = EValue.from(inputTensor)

// Run inference
val outputs = module.forward(inputEValue)
val scores = outputs[0].toTensor().dataAsFloatArray

Linux embebido

Para sistemas Linux embebidos, utiliza la API C++ de ExecuTorch:

#include <executorch/extension/module/module.h>

// Load model
auto module = torch::executor::Module("yolo26n.pte");

// Prepare input
std::vector<float> input_data = preprocessImage(image);
auto input_tensor = torch::executor::Tensor(input_data, {1, 3, 640, 640});

// Run inference
auto outputs = module.forward({input_tensor});

Para más detalles sobre cómo integrar ExecuTorch en tus aplicaciones, visita la documentación de ExecuTorch.

Optimización del rendimiento

Optimización del tamaño del modelo

Para reducir el tamaño del modelo para el despliegue:

• Usa modelos más pequeños: Empieza con YOLO26n (nano) para obtener la huella más pequeña
• Reduce la resolución de entrada: Usa tamaños de imagen más pequeños (por ejemplo, imgsz=320 o imgsz=416)
• Cuantización: Aplica técnicas de cuantización (soportadas en futuras versiones de ExecuTorch)

Optimización de la velocidad de inferencia

Para una inferencia más rápida:

• Backend XNNPACK: El backend predeterminado XNNPACK proporciona una inferencia de CPU optimizada
• Aceleración por hardware: Utiliza delegados específicos de la plataforma (por ejemplo, CoreML para iOS)
• Procesamiento por lotes: Procesa múltiples imágenes cuando sea posible

Benchmarks

El equipo de Ultralytics realizó una comparativa de los modelos YOLO26, contrastando velocidad y precisión entre PyTorch y ExecuTorch.

Solución de problemas

Problemas comunes

Issue: Python version error

Solución: ExecuTorch requiere Python 3.10 o superior. Actualiza tu instalación de Python:

# Using conda
conda create -n executorch python=3.10
conda activate executorch

Issue: Export fails during first run

Solución: Es posible que ExecuTorch necesite descargar y compilar componentes en el primer uso. Asegúrate de tener:

pip install --upgrade executorch

Issue: Import errors for ExecuTorch modules

Solución: Asegúrate de que ExecuTorch esté instalado correctamente:

pip install executorch --force-reinstall

Para más ayuda sobre solución de problemas, visita los Issues de GitHub de Ultralytics o la documentación de ExecuTorch.

Resumen

Exportar modelos YOLO26 al formato ExecuTorch permite un despliegue eficiente en dispositivos móviles y edge. Con la integración nativa de PyTorch, soporte multiplataforma y rendimiento optimizado, ExecuTorch es una excelente opción para aplicaciones de IA edge.

Conclusiones clave:

• ExecuTorch proporciona un despliegue edge nativo de PyTorch con un rendimiento excelente
• La exportación es sencilla con el parámetro format='executorch'
• Los modelos están optimizados para CPUs móviles mediante el backend XNNPACK
• Soporta plataformas iOS, Android y Linux embebido
• Requiere Python 3.10+ y el compilador FlatBuffers

Preguntas frecuentes

¿Cómo exporto un modelo YOLO26 al formato ExecuTorch?

Exporta un modelo YOLO26 a ExecuTorch usando Python o la CLI:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="executorch")

o

yolo export model=yolo26n.pt format=executorch

¿Cuáles son los requisitos del sistema para la exportación a ExecuTorch?

La exportación a ExecuTorch requiere:

• Python 3.10 o superior
• Paquete executorch (instálalo vía pip install executorch)
• PyTorch (se instala automáticamente con ultralytics)

Nota: Durante la primera exportación, ExecuTorch descargará y compilará automáticamente los componentes necesarios, incluido el compilador FlatBuffers.

¿Puedo ejecutar la inferencia con modelos ExecuTorch directamente en Python?

Los modelos de ExecuTorch (archivos .pte) están diseñados para su despliegue en dispositivos móviles y edge utilizando el runtime de ExecuTorch. No pueden cargarse directamente con YOLO() para la inferencia en Python. Debes integrarlos en tu aplicación objetivo utilizando las bibliotecas del runtime de ExecuTorch.

¿Qué plataformas son compatibles con ExecuTorch?

ExecuTorch soporta:

• Móvil: iOS y Android
• Linux embebido: Raspberry Pi, NVIDIA Jetson y otros dispositivos ARM
• Escritorio: Linux, macOS y Windows (para desarrollo)

¿Cómo se compara ExecuTorch con TFLite para el despliegue móvil?

Tanto ExecuTorch como TFLite son excelentes para el despliegue móvil:

• ExecuTorch: Mejor integración con PyTorch, flujo de trabajo nativo de PyTorch, ecosistema en crecimiento
• TFLite: Más maduro, mayor soporte de hardware, más ejemplos de despliegue

Elige ExecuTorch si ya usas PyTorch y quieres una ruta de despliegue nativa. Elige TFLite para la máxima compatibilidad y herramientas maduras.

¿Puedo usar modelos de ExecuTorch con aceleración por GPU?

¡Sí! ExecuTorch soporta aceleración por hardware a través de varios backends:

• GPU móvil: Vía delegados Vulkan, Metal o OpenCL
• NPU/DSP: Vía delegados específicos de la plataforma
• Predeterminado: XNNPACK para una inferencia de CPU optimizada

Consulta la documentación de ExecuTorch para la configuración específica de cada backend.