Implante YOLO11 en dispositivos móviles y periféricos con ExecuTorch

La implementación de modelos de visión por ordenador 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 de borde, permite una inferencia eficiente en el dispositivo para Ultralytics YOLO de Ultralytics.

Esta guía describe cómo exportar los modelos Ultralytics YOLO al formato ExecuTorch, lo que le permite desplegar sus 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 las capacidades de inferencia 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 principales de ExecuTorch

ExecuTorch proporciona varias funciones potentes para implantar los modelosYOLO Ultralytics en dispositivos periféricos:

• Formato de modelo portátil: ExecuTorch utiliza el .pte PyTorch ExecuTorch), cuyo tamaño y velocidad de carga están optimizados para dispositivos con recursos limitados.

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

• Cuantificación: Compatibilidad integrada con técnicas de cuantificació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 independiente para facilitar la integración.

Opciones de implantación con ExecuTorch

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

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

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

• Dispositivos Edge AI: Despliegue en hardware de IA de borde especializado con delegados personalizados para acelerar la inferencia.

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

Exportación de modelosYOLO11 Ultralytics a ExecuTorch

La conversión de los modelosYOLO11 Ultralytics al formato ExecuTorch permite una implantación eficaz en dispositivos móviles y periféricos.

Instalación

La exportación de 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 muy 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 a 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.)

Utilización de modelos ExecuTorch exportados

Una vez exportado el modelo, deberá integrarlo en la aplicación de destino mediante el tiempo de ejecución de ExecuTorch.

Integración móvil

Para aplicaciones móvilesiOSAndroid), necesitarás:

1. Añada ExecuTorch Runtime: Incluir la biblioteca de tiempo de ejecución ExecuTorch en su proyecto móvil.
2. Modelo de carga: Cargar el .pte en su aplicación
3. Ejecutar Inferencia: Procesar imágenes y obtener predicciones

Ejemplo de integración 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 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 más detalles sobre la integración de ExecuTorch en sus aplicaciones, visite 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 despliegue:

• Utiliza modelos más pequeños: Empieza con el YOLO11n (nano) para obtener la huella más pequeña.
• Resolución de entrada inferior: Utilice tamaños de imagen más pequeños (por ejemplo, imgsz=320 o imgsz=416)
• Cuantización: Aplicar técnicas de cuantificación (compatible con futuras versiones de ExecuTorch).

Optimización de la velocidad de inferencia

Para una inferencia más rápida:

• Backend XNNPACK: El backend XNNPACK por defecto proporciona una inferencia de CPU optimizada.
• Aceleración por hardware: Utilizar delegados específicos de la plataforma (por ejemplo, CoreML para iOS).
• Procesamiento por lotes: Procese varias imágenes cuando sea posible

Benchmarks

El equipo Ultralytics realizó una evaluación comparativa 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 :

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

Problema: Export fails during first run

Solución: ExecuTorch puede necesitar descargar y compilar componentes en el primer uso. Asegúrese de que tiene:

```bash
pip install --upgrade executorch
```

Problema: Import errors for ExecuTorch modules

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

```bash
pip install executorch --force-reinstall
```

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

Resumen

La exportación de modelos YOLO11 al formato ExecuTorch permite un despliegue eficiente en dispositivos móviles y de borde. Gracias a la integración PyTorch, la compatibilidad multiplataforma y el rendimiento optimizado, ExecuTorch es una opción excelente para las aplicaciones de inteligencia artificial.

Principales conclusiones:

• ExecuTorch proporciona un despliegue de borde PyTorch con un rendimiento excelente
• La exportación es sencilla con format='executorch' parámetro
• Los modelos se optimizan para CPU móviles mediante el backend XNNPACK
• Compatible con iOS, Android y plataformas Linux integradas
• Requiere Python 3.10+ y el compilador FlatBuffers

Preguntas frecuentes

¿Cómo se exporta un modelo YOLO11 al formato ExecuTorch?

Exporte un modelo YOLO11 a ExecuTorch utilizando Python o CLI:

```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
model.export(format="executorch")
```

o

```bash
yolo export model=yolo11n.pt format=executorch
```

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

ExecuTorch exportación requiere:

• Python 3.10 o superior
• executorch (instalación mediante 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?

Modelos ExecuTorch (.pte ) están diseñados para su despliegue en dispositivos móviles y periféricos mediante el tiempo de ejecución de ExecuTorch. No pueden cargarse directamente con YOLO() para la inferencia en Python. Debe integrarlas en su aplicación de destino utilizando las bibliotecas de tiempo de ejecución de ExecuTorch.

¿Qué plataformas son compatibles con ExecuTorch?

ExecuTorch es compatible:

• 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 la implantación móvil?

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

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

Elija ExecuTorch si ya utiliza PyTorch y desea una ruta de despliegue nativa. Elija TFLite para obtener la máxima compatibilidad y herramientas maduras.

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

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

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

Consulte la documentación de ExecuTorch para obtener información sobre la configuración específica del backend.

📅 Creado hace 0 días ✏️ Actualizado hace 0 días

Comentarios