Implementa YOLO26 en dispositivos móviles y edge con ExecuTorch#

Implementar modelos de visión por computador en dispositivos edge, como smartphones, tablets y sistemas integrados, 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 edge, permite realizar inferencias eficientes en el dispositivo con modelos de Ultralytics YOLO.

Esta guía explica cómo exportar modelos de Ultralytics YOLO al formato ExecuTorch, lo que te permite implementar 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 en plataformas móviles y edge. Diseñado para ser portátil y eficiente, ExecuTorch permite ejecutar programas de PyTorch en una amplia variedad de plataformas informáticas.

Funciones principales de ExecuTorch#

ExecuTorch proporciona varias funciones avanzadas para implementar modelos de Ultralytics YOLO en dispositivos edge:

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

• Backend XNNPACK: La integración predeterminada con XNNPACK proporciona inferencias altamente optimizadas en CPU móviles, con un rendimiento excelente sin necesidad de hardware especializado.

• Preparado para la 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 mediante el backend XNNPACK.

• Eficiencia de memoria: La gestión optimizada de la memoria reduce la huella de memoria en tiempo de ejecución, por lo que resulta adecuada 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 independiente para facilitar la integración.

Opciones de implementación con ExecuTorch#

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

• Aplicaciones móviles: Implementa en aplicaciones de iOS y Android con rendimiento nativo para habilitar la detección de objetos en tiempo real en apps móviles.

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

• Dispositivos de IA edge: Implementa en hardware especializado de IA edge con delegados personalizados para acelerar la inferencia.

• Dispositivos IoT: Intégralo en dispositivos IoT para realizar inferencias en el dispositivo sin necesidad de conectividad con 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 ExecuTorch permite implementarlos de forma 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, además del paquete executorch:

# Install Ultralytics package
pip install ultralytics

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

Uso#

Exportar modelos YOLO26 a ExecuTorch es sencillo:

El formato ExecuTorch admite los modos Export, Predict y Validate. Exporta tu modelo y, después, carga el modelo exportado para ejecutar inferencias 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 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#

Después de exportar tu modelo, tendrás que integrarlo en la aplicación de destino mediante el entorno de ejecución de ExecuTorch.

Integración móvil#

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

1. Añadir el entorno de ejecución de ExecuTorch: Incluye la biblioteca del entorno de ejecución de ExecuTorch en tu proyecto móvil.
2. Cargar el modelo: Carga el archivo .pte en tu aplicación.
3. Ejecutar la 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 AAR de ExecuTorch para Android 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 integrado#

Para sistemas Linux integrados, 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 información 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 durante la implementación:

• Utiliza modelos más pequeños: Empieza con YOLO26n (nano) para obtener la menor huella posible.
• Reduce la 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 con futuras versiones de ExecuTorch).

Optimización de la velocidad de inferencia#

Para acelerar la inferencia:

• Backend XNNPACK: El backend XNNPACK predeterminado proporciona inferencias optimizadas en CPU.
• Aceleración de hardware: Utiliza delegados específicos de la plataforma (por ejemplo, CoreML para iOS).
• Procesamiento por lotes: Procesa varias imágenes cuando sea posible.

Evaluaciones comparativas#

El equipo de Ultralytics comparó modelos YOLO26, analizando la velocidad y la precisión en PyTorch y ExecuTorch.

Solución de problemas#

Problemas habituales#

Problema: Python version error

Solución: ExecuTorch requiere Python 3.10 a 3.13. Crea un entorno con una versión compatible:

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

Problema: Export fails during first run

Solución: Asegúrate de tener instalada la versión más reciente del wheel precompilado 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 sobre la resolución de problemas, visita los problemas de Ultralytics en GitHub o la documentación de ExecuTorch.

Resumen#

Exportar modelos YOLO26 al formato ExecuTorch permite implementarlos de forma eficiente en dispositivos móviles y edge. Gracias a su integración nativa con PyTorch, compatibilidad multiplataforma y rendimiento optimizado, ExecuTorch es una excelente opción para aplicaciones de IA edge.

Conclusiones principales:

• ExecuTorch proporciona una implementación edge nativa de PyTorch con un rendimiento excelente.
• La exportación es sencilla con el parámetro format='executorch'.
• Los modelos están optimizados para CPU móviles mediante el backend XNNPACK.
• Admite plataformas iOS, Android y Linux integrado.
• Requiere Python 3.10-3.13 y PyTorch >= 2.9.0.

Preguntas frecuentes#