Distribuisci YOLO26 su dispositivi mobili 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, consente un'inferenza efficiente on-device perUltralytics YOLO ben addestrati.

Questa guida illustra come esportare i modelli Ultralytics YOLO nel formato ExecuTorch, permettendoti 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 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 fornisce diverse potenti funzionalità per la distribuzione dei 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 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: Una gestione della memoria ottimizzata riduce l'impronta di memoria in runtime, rendendolo adatto a dispositivi con RAM limitata.

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

• 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 in dispositivi IoT per l'inferenza on-device senza necessità di connettività cloud.

Esportazione di modelli Ultralytics YOLO26 in ExecuTorch

Convertire i modelli Ultralytics YOLO26 nel formato ExecuTorch consente una distribuzione efficiente su dispositivi mobili 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 migliori pratiche relative al processo di installazione, consulta la nostra Guida all'installazione di YOLO26. Mentre installi i pacchetti richiesti per YOLO26, se riscontri difficoltà, 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 dell'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 mobili (iOS/Android), dovrai:

1. Aggiungere il runtime ExecuTorch: Includi la libreria runtime di ExecuTorch nel tuo progetto mobile
2. Caricare il modello: Carica il file.ptenella tua applicazione
3. Esegui l'inferenza: Elabora le immagini e ottieni previsioni

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 la 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 maggiori dettagli sull'integrazione di ExecuTorch nelle tue applicazioni, visita laDocumentazione ExecuTorch.

Ottimizzazione delle prestazioni

Ottimizzazione delle dimensioni del modello

Per ridurre le dimensioni del modello per la distribuzione:

• Usa modelli più piccoli: Inizia con YOLO26n (nano) per l'impronta minore
• Risoluzione di input inferiore: Usa dimensioni dell'immagine più piccole (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 Ultralytics ha effettuato il benchmark dei modelli YOLO26, confrontando velocità e precisione tra PyTorch e ExecuTorch.

Risoluzione dei problemi

Problemi comuni

Problema: 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

Problema: Export fails during first run

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

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, visita leGitHub Issues di Ultralytics o Documentazione ExecuTorch.

Sommario

L'esportazione dei modelli YOLO26 nel formato ExecuTorch consente una distribuzione efficiente su dispositivi mobili ed edge. Con l'integrazione nativa in PyTorch, il supporto multipiattaforma e le prestazioni ottimizzate, ExecuTorch è una scelta eccellente per le applicazioni di Edge AI.

Punti chiave:

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

FAQ

Come esporto 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 in ExecuTorch?

L'esportazione in ExecuTorch richiede:

• Python 3.10 o superiore
• executorchpacchetto (installa tramitepip 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 (.pte file) sono progettati per il deployment su dispositivi mobile ed edge utilizzando il runtime di ExecuTorch. Non possono essere caricati direttamente con YOLO() per l'inferenza in Python. Devi integrarli nella tua applicazione di destinazione utilizzando le librerie del 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 il deployment mobile?

Sia ExecuTorch che TFLite sono eccellenti per il deployment mobile:

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

Scegli ExecuTorch se stai già utilizzando PyTorch e desideri un percorso di deployment 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:

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

Fai riferimento alla Documentazione ExecuTorch per la configurazione specifica del backend.