Distribuisci YOLO26 su dispositivi mobili e edge con ExecuTorch#

Il deployment 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 un'inferenza efficiente on-device per i modelli Ultralytics YOLO.

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

Perché esportare in ExecuTorch?#

ExecuTorch è la soluzione end-to-end di PyTorch per abilitare funzionalità di inferenza on-device su dispositivi mobili ed edge. Costruito con l'obiettivo di essere portabile ed efficiente, ExecuTorch può essere utilizzato per eseguire programmi PyTorch su un'ampia varietà di piattaforme di calcolo.

Caratteristiche principali di ExecuTorch#

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

• Formato Modello Portabile: ExecuTorch utilizza il formato .pte (PyTorch ExecuTorch), che è ottimizzato per le dimensioni e la velocità di caricamento su dispositivi con risorse limitate.

• Backend XNNPACK: L'integrazione predefinita con XNNPACK fornisce un'inferenza altamente ottimizzata su CPU mobili, offrendo eccellenti prestazioni 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; Ultralytics attualmente esporta modelli FP32 tramite il backend XNNPACK.

• Efficienza della memoria: La gestione ottimizzata della memoria riduce l'impronta di memoria durante l'esecuzione, rendendolo adatto a dispositivi con RAM limitata.

• Metadati del modello: I modelli esportati includono metadati (dimensione 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 varie piattaforme edge e mobili:

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

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

• Dispositivi Edge AI: Distribuisci su hardware Edge AI specializzato con delegati personalizzati per un'inferenza accelerata.

• Dispositivi IoT: Integra nei dispositivi IoT per l'inferenza on-device senza necessità di connettività cloud.

Attività supportate#

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

Esportazione di modelli Ultralytics YOLO26 in ExecuTorch#

Convertire i modelli Ultralytics YOLO26 nel formato ExecuTorch abilita una distribuzione efficiente su dispositivi mobili e edge.

Installazione#

L'esportazione con ExecuTorch richiede Python 3.10-3.13 e PyTorch >= 2.9.0 insieme 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. Durante l'installazione dei pacchetti richiesti per YOLO26, se riscontri difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Utilizzo#

Esportare modelli YOLO26 in ExecuTorch è semplice:

Il formato ExecuTorch supporta le modalità Export, Predict e Validate. Esporta il tuo modello, quindi carica il modello esportato per eseguire l'inferenza o validarne la precisione.

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#

Quando esporti 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 tuo modello, dovrai integrarlo nella tua 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. Carica Modello: Carica il file .pte nella tua applicazione
3. Eseguire l'inferenza: Elabora le immagini e ottieni le predizioni

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 ExecuTorch Android AAR 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 sistemi Linux embedded, utilizza 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 maggiori dettagli sull'integrazione di ExecuTorch nelle tue applicazioni, visita la Documentazione di ExecuTorch.

Ottimizzazione delle prestazioni#

Ottimizzazione della dimensione del modello#

Per ridurre le dimensioni del modello per la distribuzione:

• Usa modelli più piccoli: Inizia con YOLO26n (nano) per l'ingombro minore
• Riduci la Risoluzione di Input: Usa dimensioni d'immagine inferiori (ad es. imgsz=320 o imgsz=416)
• Quantizzazione: Applica tecniche di quantizzazione (supportate nelle future versioni di ExecuTorch)

Ottimizzazione della velocità di inferenza#

Per un'inferenza più rapida:

• Backend XNNPACK: Il backend XNNPACK predefinito fornisce un'inferenza CPU ottimizzata
• Accelerazione hardware: Usa delegati specifici per la piattaforma (es. CoreML per iOS)
• Elaborazione in batch: Elabora più immagini quando possibile

Benchmark#

Il team di Ultralytics ha testato i modelli YOLO26, confrontando velocità e precisione tra PyTorch ed ExecuTorch.

Risoluzione dei problemi#

Problemi comuni#

Problema: Python version error

Soluzione: ExecuTorch richiede Python 3.10 o superiore. Aggiorna la tua installazione di Python:

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

Problema: Export fails during first run

Soluzione: Assicurati di avere installato l'ultimo wheel precompilato di 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 aiuto sulla risoluzione dei problemi, visita le GitHub Issues di Ultralytics o la Documentazione di ExecuTorch.

Riepilogo#

Esportare i modelli YOLO26 nel formato ExecuTorch abilita una distribuzione efficiente su dispositivi mobili e edge. Con l'integrazione nativa di PyTorch, il supporto multipiattaforma e le prestazioni ottimizzate, ExecuTorch è una scelta eccellente per le applicazioni Edge AI.

Punti chiave:

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

FAQ#