Distribuisci YOLO26 su dispositivi mobili ed edge con ExecuTorch#

La distribuzione di modelli di computer vision su dispositivi edge come smartphone, tablet e sistemi embedded richiede un runtime ottimizzato che bilanci le prestazioni con i vincoli delle risorse. ExecuTorch, la soluzione di PyTorch per l'edge computing, consente di eseguire in modo efficiente l'inferenza sul dispositivo con i modelli Ultralytics YOLO.

Questa guida illustra come esportare i modelli Ultralytics YOLO nel formato ExecuTorch, consentendoti di distribuire i tuoi modelli su dispositivi mobili ed edge con prestazioni ottimizzate.

Perché esportare in ExecuTorch?#

ExecuTorch è la soluzione end-to-end di PyTorch per abilitare l'inferenza sul dispositivo su piattaforme mobili ed edge. Progettato per essere portabile ed efficiente, ExecuTorch può essere utilizzato per eseguire programmi PyTorch su un'ampia varietà di piattaforme di elaborazione.

Funzionalità principali di ExecuTorch#

ExecuTorch offre diverse potenti funzionalità per distribuire i modelli Ultralytics YOLO sui dispositivi edge:

• Formato del modello portatile: ExecuTorch utilizza il formato .pte (PyTorch ExecuTorch), ottimizzato per le dimensioni e la velocità di caricamento sui dispositivi con risorse limitate.

• Backend XNNPACK: l'integrazione predefinita con XNNPACK offre un'inferenza altamente ottimizzata sulle CPU mobili, garantendo prestazioni eccellenti senza richiedere hardware specializzato.

• Pronto per la quantizzazione: l'ecosistema ExecuTorch supporta tecniche di quantizzazione per ridurre le dimensioni del modello e migliorare la velocità di inferenza; attualmente Ultralytics esporta modelli FP32 tramite il backend XNNPACK.

• Efficienza della memoria: la gestione ottimizzata della memoria riduce l'occupazione di memoria a runtime, rendendo ExecuTorch adatto ai dispositivi con RAM limitata.

• Metadati del modello: i modelli esportati includono i metadati (dimensioni dell'immagine, nomi delle classi, ecc.) in un file YAML separato per una facile integrazione.

Opzioni di distribuzione con ExecuTorch#

I modelli ExecuTorch possono essere distribuiti su diverse piattaforme edge e mobili:

• Applicazioni mobili: distribuiscili su applicazioni iOS e Android con prestazioni native, abilitando il rilevamento degli oggetti in tempo reale nelle app mobili.

• Sistemi embedded: eseguili su dispositivi Linux embedded come Raspberry Pi, NVIDIA Jetson e altri sistemi basati su ARM con prestazioni ottimizzate.

• Dispositivi edge AI: distribuiscili su hardware edge AI specializzato con delegate personalizzati per accelerare l'inferenza.

• Dispositivi IoT: integrali nei dispositivi IoT per eseguire l'inferenza sul dispositivo senza richiedere la connettività al cloud.

Attività supportate#

L'esportazione ExecuTorch supporta tutte e sette le attività Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

Esportazione dei modelli Ultralytics YOLO26 in ExecuTorch#

La conversione dei modelli Ultralytics YOLO26 nel formato ExecuTorch consente una distribuzione efficiente su dispositivi mobili ed edge.

Installazione#

L'esportazione ExecuTorch richiede Python 3.10-3.13 e PyTorch >= 2.9.0, oltre al pacchetto executorch:

# Install Ultralytics package
pip install ultralytics

Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di YOLO26. Se durante l'installazione dei pacchetti richiesti per YOLO26 riscontri difficoltà, consulta la nostra guida ai problemi comuni per trovare soluzioni e suggerimenti.

Utilizzo#

Esportare i modelli YOLO26 in ExecuTorch è semplice:

Il formato ExecuTorch supporta le modalità Esporta, Prevedi e Convalida. Esporta il modello, quindi carica il modello esportato per eseguire l'inferenza o convalidarne l'accuratezza.

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")

Argomenti di esportazione#

Durante l'esportazione nel formato ExecuTorch, puoi specificare i seguenti argomenti:

Struttura dell'output#

L'esportazione ExecuTorch crea una directory contenente il modello e i metadati:

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

Utilizzo dei modelli ExecuTorch esportati#

Dopo aver esportato il modello, dovrai integrarlo nell'applicazione di destinazione utilizzando il runtime ExecuTorch.

Integrazione mobile#

Per le applicazioni mobili (iOS/Android), dovrai:

1. Aggiungere il runtime ExecuTorch: includi la libreria runtime ExecuTorch nel tuo progetto mobile
2. Caricare il modello: carica il file .pte nella tua applicazione
3. Eseguire l'inferenza: elabora le immagini e ottieni le previsioni

iOS#

Esempio di integrazione 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#

Aggiungi l'AAR Android di ExecuTorch da Maven Central:

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

Esempio di integrazione 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 embedded#

Per i sistemi Linux embedded, usa l'API C++ di 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);

Per ulteriori dettagli sull'integrazione di ExecuTorch nelle tue applicazioni, visita la documentazione di ExecuTorch.

Ottimizzazione delle prestazioni#

Ottimizzazione delle dimensioni del modello#

Per ridurre le dimensioni del modello in fase di distribuzione:

• Usa modelli più piccoli: inizia con YOLO26n (nano) per ridurre al minimo l'ingombro
• Riduci la risoluzione di input: usa dimensioni delle immagini inferiori (ad es. imgsz=320 o imgsz=416)
• Quantizzazione: applica tecniche di quantizzazione (supportate nelle versioni future di ExecuTorch)

Ottimizzazione della velocità di inferenza#

Per un'inferenza più rapida:

• Backend XNNPACK: il backend XNNPACK predefinito offre un'inferenza CPU ottimizzata
• Accelerazione hardware: usa delegate specifici della piattaforma (ad es. CoreML per iOS)
• Elaborazione batch: elabora più immagini quando possibile

Benchmark#

Il team Ultralytics ha sottoposto a benchmark i modelli YOLO26, confrontando velocità e accuratezza tra PyTorch ed ExecuTorch.

Risoluzione dei problemi#

Problemi comuni#

Problema: Python version error

Soluzione: ExecuTorch richiede Python 3.10 a 3.13. Crea un ambiente con una versione supportata:

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

Problema: Export fails during first run

Soluzione: assicurati di avere installata la versione più recente del wheel precompilato executorch:

pip install --upgrade executorch

Problema: Import errors for ExecuTorch modules

Soluzione: assicurati che ExecuTorch sia installato correttamente:

pip install executorch --force-reinstall

Per ulteriore assistenza nella risoluzione dei problemi, visita le issue di Ultralytics su GitHub o la documentazione di ExecuTorch.

Riepilogo#

L'esportazione dei modelli YOLO26 nel formato ExecuTorch consente una distribuzione efficiente su dispositivi mobili ed edge. Grazie all'integrazione nativa con PyTorch, al supporto multipiattaforma e alle prestazioni ottimizzate, ExecuTorch è un'ottima scelta per le applicazioni edge AI.

Punti chiave:

• ExecuTorch offre una distribuzione edge nativa per PyTorch con prestazioni eccellenti
• L'esportazione è semplice con il parametro format='executorch'
• I modelli sono ottimizzati per le CPU mobili tramite il backend XNNPACK
• Supporta le piattaforme iOS, Android e Linux embedded
• Richiede Python 3.10-3.13 e PyTorch >= 2.9.0

FAQ#