Despliega YOLO26 en dispositivos móviles y Edge con ExecuTorch#

El despliegue de modelos de visión por computador en dispositivos de borde como smartphones, tabletas y sistemas empotrados requiere un entorno de ejecución optimizado que equilibre el rendimiento con las limitaciones de recursos. ExecuTorch, la solución de PyTorch para la computación en el borde, permite una inferencia eficiente en el dispositivo para los modelos de Ultralytics YOLO.

Esta guía describe cómo exportar modelos Ultralytics YOLO al formato de ExecuTorch, permitiéndote desplegar tus modelos en dispositivos móviles y Edge con un rendimiento optimizado.

¿Por qué exportar a ExecuTorch?#

ExecuTorch es la solución de extremo a extremo de PyTorch para habilitar capacidades de inferencia en el dispositivo en dispositivos móviles y de borde. Construido con el objetivo de ser portátil y eficiente, ExecuTorch se puede utilizar para ejecutar programas de PyTorch en una amplia variedad de plataformas informáticas.

Características clave de ExecuTorch#

ExecuTorch ofrece varias características potentes para desplegar modelos de Ultralytics YOLO en dispositivos Edge:

• Formato de modelo portátil: ExecuTorch utiliza el formato .pte (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 inferencias altamente optimizadas en CPUs móviles, ofreciendo un rendimiento excelente sin necesidad de hardware especializado.

• Preparado para cuantización: El ecosistema de ExecuTorch admite técnicas de cuantización para reducir el tamaño del modelo y mejorar la velocidad de inferencia; actualmente, Ultralytics exporta modelos FP32 a través del backend de XNNPACK.

• Eficiencia de memoria: La gestión optimizada de la memoria reduce el consumo de memoria en tiempo de ejecución, lo que lo hace 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 integración sencilla.

Opciones de despliegue con ExecuTorch#

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

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

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

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

• Dispositivos IoT: Integra en dispositivos IoT para realizar inferencias localmente sin necesidad de conexión a la nube.

Tareas compatibles#

La exportación a ExecuTorch es compatible con las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esas cabezas.

Exportación de modelos Ultralytics YOLO26 a ExecuTorch#

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

Instalación#

La exportación a ExecuTorch requiere Python 3.10-3.13 y PyTorch >= 2.9.0 junto con el paquete executorch:

# Install Ultralytics package
pip install ultralytics

Para obtener instrucciones detalladas y mejores prácticas relacionadas con el proceso de instalación, consulta nuestra YOLO26 Installation guide. Si encuentras alguna dificultad al instalar los paquetes necesarios para YOLO26, consulta nuestra Common Issues guide para ver soluciones y consejos.

Uso#

Exportar modelos YOLO26 a ExecuTorch es sencillo:

El formato ExecuTorch admite los modos Export, Predict y Validate. Exporta tu modelo, luego carga el modelo 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 ExecuTorch format
model.export(format="executorch")  # creates 'yolo26n_executorch_model'

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Argumentos de exportación#

Al exportar al formato de 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/
├── model.pte               # ExecuTorch model file
└── metadata.yaml           # Model metadata (classes, image size, etc.)

Uso de modelos ExecuTorch exportados#

Tras exportar tu modelo, tendrás que integrarlo en tu aplicación de destino utilizando el entorno de ejecución de ExecuTorch.

Integración móvil#

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

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

iOS#

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/model.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);

Android#

Añade el ExecuTorch Android AAR desde Maven Central:

dependencies {
    implementation("org.pytorch:executorch-android:<version>")
}

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/model.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 de C++ de ExecuTorch:

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

using namespace ::executorch::extension;

// Load model
Module module("model.pte");

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

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

Para obtener más detalles sobre la integración de ExecuTorch en tus aplicaciones, visita la ExecuTorch Documentation.

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 YOLO26n (nano) para obtener el menor tamaño posible
• Reducir resolución de entrada: Utiliza tamaños de imagen más pequeños (por ejemplo, imgsz=320 o imgsz=416)
• Cuantización: Aplica técnicas de cuantización (compatibles 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 inferencia optimizada en CPU
• Aceleración por hardware: Utiliza delegados específicos de la plataforma (por ejemplo, CoreML para iOS)
• Procesamiento por lotes (batch): Procesa varias imágenes cuando sea posible

Benchmarks#

El equipo de Ultralytics comparó los modelos YOLO26 evaluando la velocidad y 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. Actualiza tu instalación de Python:

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

Problema: Export fails during first run

Solución: Asegúrate de tener instalado el último wheel precompilado de executorch:

pip install --upgrade executorch

Problema: Import errors for ExecuTorch modules

Solución: Asegúrate 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 ExecuTorch Documentation.

Resumen#

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

Puntos clave:

• ExecuTorch proporciona despliegue nativo en el borde con PyTorch y un excelente rendimiento
• La exportación es sencilla con el parámetro format='executorch'
• Los modelos están optimizados para CPUs móviles mediante el backend XNNPACK
• Compatible con plataformas iOS, Android y Linux embebido
• Requiere Python 3.10-3.13 y PyTorch >= 2.9.0

FAQ#