Implementar YOLO11 en Mobile & Edge con ExecuTorch

Implementar modelos de visión artificial en dispositivos periféricos como teléfonos inteligentes, tabletas y sistemas integrados requiere un tiempo de ejecución optimizado que equilibre el rendimiento con las limitaciones de recursos. ExecuTorch, la solución de PyTorch para la computación periférica, permite una Inference API eficiente en el dispositivo para los modelos Ultralytics YOLO.

Esta guía describe cómo exportar modelos Ultralytics YOLO al formato ExecuTorch, lo que le permite implementar sus modelos en dispositivos móviles y periféricos 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 en dispositivos móviles y periféricos. Construido con el objetivo de ser portátil y eficiente, ExecuTorch se puede utilizar para ejecutar programas PyTorch en una amplia variedad de plataformas informáticas.

Características clave de ExecuTorch

ExecuTorch proporciona varias funciones potentes para implementar modelos Ultralytics YOLO en dispositivos de borde:

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

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

• Soporte para la Cuantización: Soporte integrado para técnicas de cuantización para reducir el tamaño del modelo y mejorar la velocidad de inferencia, manteniendo la precisión.

• Eficiencia de memoria: La gestión optimizada de la memoria reduce la huella de memoria en tiempo de ejecución, lo que la hace adecuada para dispositivos con RAM limitada.

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

Opciones de implementación con ExecuTorch

Los modelos ExecuTorch se pueden implementar en varias plataformas móviles y de borde:

• Aplicaciones móviles: Implementación en aplicaciones iOS y Android con rendimiento nativo, lo que permite la detección de objetos en tiempo real en aplicaciones móviles.

• Sistemas integrados: Se ejecutan en dispositivos Linux integrados como Raspberry Pi, NVIDIA Jetson y otros sistemas basados en ARM con un rendimiento optimizado.

• Dispositivos Edge AI: Implemente en hardware Edge AI especializado con delegados personalizados para una inferencia acelerada.

• Dispositivos IoT: Integración en dispositivos IoT para la inferencia en el dispositivo sin necesidad de conectividad en la nube.

Exportación de modelos Ultralytics YOLO11 a ExecuTorch

Convertir modelos Ultralytics YOLO11 al formato ExecuTorch permite una implementación eficiente en dispositivos móviles y de borde.

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, consulte nuestra guía de instalación de YOLO11. Si tiene alguna dificultad al instalar los paquetes necesarios para YOLO11, consulte nuestra guía de problemas comunes para obtener soluciones y consejos.

Uso

Exportar modelos YOLO11 a ExecuTorch es sencillo:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

executorch_model = YOLO("yolo11n_executorch_model")

results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

# Export a YOLO11n PyTorch model to ExecuTorch format
yolo export model=yolo11n.pt format=executorch # creates 'yolo11n_executorch_model' directory

# Run inference with the exported model
yolo predict model=yolo11n_executorch_model source=https://ultralytics.com/images/bus.jpg

Argumentos de exportación

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

Estructura de Salida

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

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

Uso de modelos ExecuTorch exportados

Después de exportar tu modelo, necesitarás integrarlo en tu aplicación de destino utilizando el entorno de ejecución ExecuTorch.

Integración móvil

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

1. Añadir ExecuTorch Runtime: Incluye la biblioteca de tiempo de ejecución de ExecuTorch en tu proyecto móvil.
2. Cargar modelo: Cargar el .pte archivo en su aplicación
3. Ejecutar Inferencia: Procesar imágenes y obtener predicciones

Ejemplo de integración de 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/yolo11n.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 de 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/yolo11n.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 Integrado

Para sistemas Linux embebidos, utilice la API ExecuTorch C++:

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

// Load model
auto module = torch::executor::Module("yolo11n.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 obtener más detalles sobre la integración de 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 su implementación:

• Usar modelos más pequeños: Comienza con YOLO11n (nano) para la huella más pequeña
• Menor resolución de entrada: Usar tamaños de imagen más pequeños (p. ej., imgsz=320 o imgsz=416)
• Cuantización: Aplique técnicas de cuantización (compatibles con futuras versiones de ExecuTorch)

Optimización de la Velocidad de Inferencia

Para una inferencia más rápida:

• Backend XNNPACK: El backend XNNPACK predeterminado proporciona una inferencia de CPU optimizada.
• Aceleración de hardware: Utilice 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ó pruebas comparativas de los modelos YOLO11, comparando la velocidad y la precisión entre PyTorch y ExecuTorch.

Solución de problemas

Problemas comunes

Problema: Python version error

Solución: ExecuTorch requiere Python 3.10 o superior. Actualice su instalación de Python:

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

Problema: Export fails during first run

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

pip install --upgrade executorch

Problema: Import errors for ExecuTorch modules

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

pip install executorch --force-reinstall

Para obtener más ayuda para la resolución de problemas, visita Ultralytics GitHub Issues o la Documentación de ExecuTorch.

Resumen

La exportación de modelos YOLO11 al formato ExecuTorch permite una implementación eficiente en dispositivos móviles y de borde. Con la integración nativa de PyTorch, el soporte multiplataforma y el rendimiento optimizado, ExecuTorch es una excelente opción para aplicaciones de IA en el borde.

Conclusiones clave:

• ExecuTorch proporciona una implementación de borde nativa de PyTorch con un rendimiento excelente
• La exportación es sencilla con format='executorch' parameter
• Los modelos están optimizados para CPUs móviles a través del backend XNNPACK
• Compatible con plataformas iOS, Android y Linux integradas
• Requiere python 3.10+ y compilador FlatBuffers

Preguntas frecuentes

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

Exporta un modelo YOLO11 a ExecuTorch usando python o CLI:

from ultralytics import YOLO

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

o

yolo export model=yolo11n.pt format=executorch

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

La exportación a ExecuTorch requiere:

• Python 3.10 o superior
• executorch paquete (instalar vía pip install executorch)
• PyTorch (instalado automáticamente con ultralytics)

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

¿Puedo ejecutar inferencias con modelos ExecuTorch directamente en Python?

Modelos ExecuTorch (.pte archivos) están diseñados para su implementación en dispositivos móviles y periféricos utilizando el entorno de ejecución ExecuTorch. No se pueden cargar directamente con YOLO() para la inferencia en python. Debe integrarlos en su aplicación de destino utilizando las bibliotecas de tiempo de ejecución de ExecuTorch.

¿Qué plataformas son compatibles con ExecuTorch?

ExecuTorch soporta:

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

¿Cómo se compara ExecuTorch con TFLite para la implementación móvil?

Tanto ExecuTorch como TFLite son excelentes para la implementación móvil:

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

Elija ExecuTorch si ya está utilizando PyTorch y desea una ruta de implementación nativa. Elija TFLite para obtener la máxima compatibilidad y herramientas maduras.

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

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

• GPU móvil: A través de delegados de Vulkan, Metal u OpenCL
• NPU/DSP: A través de delegados específicos de la plataforma
• Predeterminado: XNNPACK para la inferencia de CPU optimizada

Consulte la Documentación de ExecuTorch para la configuración específica del backend.

📅 Creado hace 1 mes ✏️ Actualizado hace 25 días

Comentarios