Link to this sectionDespliega YOLO26 en dispositivos móviles y 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 limitaciones de recursos. ExecuTorch, la solución de PyTorch para computación en el borde (edge computing), permite realizar inferencias eficientes en el propio dispositivo para 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.

Link to this section¿Por qué exportar a ExecuTorch?#

ExecuTorch es la solución integral de PyTorch para habilitar capacidades de inferencia en dispositivos móviles y Edge. Creado 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.

Link to this sectionCaracterí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 en tamaño y velocidad de carga para 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.

Link to this sectionOpciones 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.

Link to this sectionExportació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.

Link to this sectionInstalació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 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 encontrar soluciones y consejos.

Link to this sectionUso#

Exportar modelos YOLO26 a ExecuTorch es sencillo:

El formato de ExecuTorch admite los modos Export, Predict y Validate. Exporta tu modelo y luego cárgalo 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")

Link to this sectionArgumentos de exportación#

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

Link to this sectionEstructura 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.)

Link to this sectionUso 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.

Link to this sectionIntegració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 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/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);

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

Link to this sectionLinux 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 más detalles sobre cómo integrar ExecuTorch en tus aplicaciones, visita la documentación de ExecuTorch.

Link to this sectionOptimización del rendimiento#

Link to this sectionOptimizació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
• 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 en futuras versiones de ExecuTorch)

Link to this sectionOptimizació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

Link to this sectionBenchmarks#

El equipo de Ultralytics comparó los modelos YOLO26 evaluando la velocidad y precisión entre PyTorch y ExecuTorch.

Link to this sectionSolución de problemas#

Link to this sectionProblemas 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: Asegúrate de tener instalada la versión más reciente del wheel precompilado de executorch:

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 obtener más ayuda, visita los problemas de GitHub de Ultralytics o la documentación de ExecuTorch.

Link to this sectionResumen#

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

Link to this sectionFAQ#

Link to this section¿Cómo exporto un modelo YOLO26 al formato de 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

Link to this section¿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 mediante pip install executorch)
• PyTorch (instalado automáticamente con ultralytics)

Nota: El paquete executorch incluye wheels precompilados (con el backend XNNPACK), por lo que no es necesario ningún paso de compilación adicional durante la exportación.

Link to this section¿Puedo ejecutar inferencias con modelos de ExecuTorch directamente en Python?#

Los modelos de ExecuTorch se pueden cargar directamente con YOLO() para realizar inferencias y validaciones en Python (consulta los ejemplos de Predict/Validate anteriores), y también se pueden desplegar en dispositivos móviles y Edge utilizando las bibliotecas de tiempo de ejecución de ExecuTorch.

Link to this section¿Qué plataformas son compatibles con ExecuTorch?#

ExecuTorch es compatible con:

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

Link to this section¿Cómo se compara ExecuTorch con TFLite para el despliegue en móviles?#

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

• 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 utilizas PyTorch y quieres una ruta de despliegue nativa. Elige TFLite para obtener la máxima compatibilidad y herramientas maduras.

Link to this section¿Puedo usar modelos de ExecuTorch con aceleración por GPU?#

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

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

Consulta la Documentación de ExecuTorch para configurar backends específicos.