Link to this sectionDistribuisci YOLO26 su dispositivi mobili e 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 mobili e edge con prestazioni ottimizzate.

Link to this sectionPerché esportare in ExecuTorch?#

ExecuTorch è la soluzione end-to-end di PyTorch per abilitare funzionalità di inferenza on-device su dispositivi mobili e 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.

Link to this sectionCaratteristiche 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), ottimizzato per dimensioni e 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.

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

Link to this sectionEsportazione di modelli Ultralytics YOLO26 in ExecuTorch#

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

Link to this sectionInstallazione#

L'esportazione 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 YOLO26. Durante l'installazione dei pacchetti necessari per YOLO26, se riscontri difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Link to this sectionUtilizzo#

Esportare modelli YOLO26 in ExecuTorch è semplice:

Il formato ExecuTorch supporta le modalità Export, Predict e Validate. Esporta il tuo modello, quindi caricalo 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")

Link to this sectionArgomenti di esportazione#

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

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

Link to this sectionUtilizzo dei modelli ExecuTorch esportati#

Dopo aver esportato il tuo modello, dovrai integrarlo nella tua applicazione di destinazione utilizzando il runtime ExecuTorch.

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

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

Link to this sectionLinux 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 ulteriori dettagli sull'integrazione di ExecuTorch nelle tue applicazioni, visita la documentazione di ExecuTorch.

Link to this sectionOttimizzazione delle prestazioni#

Link to this sectionOttimizzazione 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 dell'immagine più piccole (es. imgsz=320 o imgsz=416)
• Quantizzazione: Applica tecniche di quantizzazione (supportate nelle future versioni di ExecuTorch)

Link to this sectionOttimizzazione 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

Link to this sectionBenchmark#

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

Link to this sectionRisoluzione dei problemi#

Link to this sectionProblemi comuni#

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

Issue: Export fails during first run

Soluzione: Assicurati di avere installato l'ultimo wheel precompilato di executorch:

pip install --upgrade executorch

Issue: Import errors for ExecuTorch modules

Soluzione: Assicurati che ExecuTorch sia installato correttamente:

pip install executorch --force-reinstall

Per ulteriore assistenza, visita le GitHub Issues di Ultralytics o la documentazione di ExecuTorch.

Link to this sectionRiepilogo#

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

Link to this sectionFAQ#

Link to this sectionCome 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

Link to this sectionQuali sono i requisiti di sistema per l'esportazione ExecuTorch?#

L'esportazione ExecuTorch richiede:

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

Nota: Il pacchetto executorch include wheel precompilati (con il backend XNNPACK), quindi non è necessario alcun passaggio di compilazione aggiuntivo durante l'esportazione.

Link to this sectionPosso eseguire l'inferenza con i modelli ExecuTorch direttamente in Python?#

I modelli ExecuTorch possono essere caricati direttamente con YOLO() per l'inferenza e la validazione in Python (vedi gli esempi di Predict/Validate sopra), e possono anche essere distribuiti su dispositivi mobili e edge utilizzando le librerie runtime di ExecuTorch.

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

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

Link to this sectionPosso utilizzare i modelli ExecuTorch con 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

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