Distribuisci YOLO26 su dispositivi Mobile ed Edge con ExecuTorch

Distribuire modelli di computer vision su dispositivi edge come smartphone, tablet e sistemi embedded richiede un runtime ottimizzato che bilanci prestazioni e vincoli di risorse. ExecuTorch, la soluzione di PyTorch per l'edge computing, abilita 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 mobile ed 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 mobile ed edge. Creato 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 fornisce diverse funzionalità potenti per distribuire i modelli Ultralytics YOLO su dispositivi edge:

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

• Backend XNNPACK: L'integrazione predefinita con XNNPACK fornisce un'inferenza altamente ottimizzata su CPU mobile, offrendo prestazioni eccellenti senza richiedere hardware specializzato.

• Supporto alla Quantizzazione: Supporto integrato per tecniche di quantizzazione per ridurre le dimensioni del modello e migliorare la velocità di inferenza mantenendo la precisione.

• Efficienza della Memoria: La gestione ottimizzata della memoria riduce l'impronta di memoria a runtime, 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 mobile:

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

• Sistemi Embedded: Eseguili 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 un'inferenza on-device senza requisiti di connettività cloud.

Esportazione dei modelli Ultralytics YOLO26 in ExecuTorch

Convertire i modelli Ultralytics YOLO26 nel formato ExecuTorch permette una distribuzione efficiente su dispositivi mobile ed edge.

Installazione

L'esportazione ExecuTorch richiede Python 3.10 o superiore e dipendenze specifiche:

# 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 riscontri difficoltà durante l'installazione dei pacchetti richiesti per YOLO26, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Utilizzo

Esportare i modelli YOLO26 in ExecuTorch è semplice:

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to ExecuTorch format
model.export(format="executorch")  # creates 'yolo26n_executorch_model' directory

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

# Run inference on a single image
results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

Argomenti di esportazione

Quando esporti nel formato ExecuTorch, puoi specificare i seguenti argomenti:

Struttura di output

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

yolo26n_executorch_model/
├── yolo26n.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 mobile (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 predizioni

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

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/yolo26n.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, usa l'API C++ di ExecuTorch:

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

// Load model
auto module = torch::executor::Module("yolo26n.pte");

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

// Run inference
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 della Dimensione del Modello

Per ridurre le dimensioni del modello per la distribuzione:

• Usa Modelli più piccoli: Inizia con YOLO26n (nano) per il minor ingombro
• Riduci la Risoluzione di Input: Usa dimensioni d'immagine minori (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 predefinito XNNPACK fornisce un'inferenza CPU ottimizzata
• Accelerazione Hardware: Usa delegati specifici per la piattaforma (es. CoreML per iOS)
• Elaborazione a Lotti (Batching): Elabora più immagini quando possibile

Benchmark

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

Risoluzione dei problemi

Problemi comuni

Issue: Python version error

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

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

Issue: Export fails during first run

Soluzione: ExecuTorch potrebbe aver bisogno di scaricare e compilare componenti al primo utilizzo. Assicurati di avere:

pip install --upgrade executorch

Issue: Import errors for ExecuTorch modules

Soluzione: Assicurati che ExecuTorch sia installato correttamente:

pip install executorch --force-reinstall

Per ulteriore aiuto nella risoluzione dei problemi, visita le GitHub Issues di Ultralytics o la Documentazione di ExecuTorch.

Riepilogo

Esportare i modelli YOLO26 nel formato ExecuTorch permette una distribuzione efficiente su dispositivi mobile ed 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 mobile tramite il backend XNNPACK
• Supporta piattaforme iOS, Android e Linux embedded
• Richiede Python 3.10+ e il compilatore FlatBuffers

FAQ

Come posso esportare un modello YOLO26 nel formato ExecuTorch?

Esporta un modello YOLO26 in 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

Quali sono i requisiti di sistema per l'esportazione ExecuTorch?

L'esportazione ExecuTorch richiede:

• Python 3.10 o superiore
• Il pacchetto executorch (installa tramite pip install executorch)
• PyTorch (installato automaticamente con ultralytics)

Nota: Durante la prima esportazione, ExecuTorch scaricherà e compilerà automaticamente i componenti necessari, incluso il compilatore FlatBuffers.

Posso eseguire l'inferenza con i modelli ExecuTorch direttamente in Python?

I modelli ExecuTorch (file .pte) sono progettati per la distribuzione su dispositivi mobile ed edge utilizzando il runtime ExecuTorch. Non possono essere caricati direttamente con YOLO() per l'inferenza in Python. Devi integrarli nella tua applicazione di destinazione utilizzando le librerie runtime di ExecuTorch.

Quali piattaforme sono supportate da ExecuTorch?

ExecuTorch supporta:

• Mobile: iOS e Android
• Linux Embedded: Raspberry Pi, NVIDIA Jetson e altri dispositivi ARM
• Desktop: Linux, macOS e Windows (per lo sviluppo)

Come si confronta ExecuTorch con TFLite per la distribuzione mobile?

Sia ExecuTorch che TFLite sono eccellenti per la distribuzione mobile:

• ExecuTorch: Migliore integrazione con PyTorch, workflow PyTorch nativo, ecosistema in crescita
• TFLite: Più maturo, supporto hardware più ampio, più esempi di distribuzione

Scegli ExecuTorch se stai già usando PyTorch e desideri un percorso di distribuzione nativo. Scegli TFLite per la massima compatibilità e strumenti maturi.

Posso usare i modelli ExecuTorch con l'accelerazione GPU?

Sì! ExecuTorch supporta l'accelerazione hardware tramite vari backend:

• Mobile GPU: Tramite delegati Vulkan, Metal o OpenCL
• NPU/DSP: Tramite delegati specifici per piattaforma
• Predefinito: XNNPACK per un'inferenza CPU ottimizzata

Consulta la Documentazione di ExecuTorch per la configurazione specifica del backend.