Implementazione di YOLO11 su mobile ed Edge con ExecuTorch

L'implementazione 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 di risorse. ExecuTorch, la soluzione di PyTorch per l'edge computing, permette un'inferenza efficiente sul dispositivo per Ultralytics YOLO per i modelli Ultralytics YOLO.

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

Perché esportare in ExecuTorch?

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

Caratteristiche principali di ExecuTorch

ExecuTorch offre diverse potenti funzioni per l'implementazione dei modelliYOLO di Ultralytics sui dispositivi edge:

• Formato del modello portatile: ExecuTorch utilizza il .pte PyTorch ExecuTorch), 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 sulle CPU mobili, offrendo prestazioni eccellenti senza richiedere hardware specializzato.

• Supporto per la quantizzazione: Supporto integrato per le 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'ingombro della memoria di runtime, rendendolo 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 facilitare l'integrazione.

Opzioni di distribuzione con ExecuTorch

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

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

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

• Dispositivi Edge AI: Distribuzione su hardware specializzato per l'IA di bordo con delegati personalizzati per un'inferenza accelerata.

• Dispositivi IoT: Integrazione nei dispositivi IoT per l'inferenza sul dispositivo senza requisiti di connettività al cloud.

Esportazione dei modelli Ultralytics YOLO11 in ExecuTorch

La conversione dei modelli Ultralytics YOLO11 in formato ExecuTorch consente un'efficiente distribuzione su dispositivi mobili ed edge.

Installazione

L'esportazione di 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 YOLO11. Durante l'installazione dei pacchetti richiesti per YOLO11, in caso di difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Utilizzo

L'esportazione dei modelli YOLO11 in ExecuTorch è semplice:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

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

executorch_model = YOLO("yolo11n_executorch_model")

results = executorch_model.predict("https://ultralytics.com/images/bus.jpg")

# Export a YOLO11n PyTorch model to ExecuTorch format
yolo export model=yolo11n.pt format=executorch # creates 'yolo11n_executorch_model' directory

# Run inference with the exported model
yolo predict model=yolo11n_executorch_model source=https://ultralytics.com/images/bus.jpg

Argomenti di esportazione

Quando si esporta in formato ExecuTorch, è possibile specificare i seguenti argomenti:

Struttura di uscita

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

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

Utilizzo dei modelli ExecuTorch esportati

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

Integrazione mobile

Per le applicazioni mobiliiOSAndroid), è necessario:

1. Aggiungere il runtime di ExecuTorch: Includere la libreria runtime di ExecuTorch nel progetto mobile.
2. Modello di carico: Caricare il file .pte nell'applicazione
3. Eseguire l'inferenza: Elaborare le immagini e ottenere le previsioni

Esempio di integrazione con 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/yolo11n.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 con 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/yolo11n.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 integrato

Per i sistemi Linux embedded, utilizzare l'API ExecuTorch C++:

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

// Load model
auto module = torch::executor::Module("yolo11n.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 vostre applicazioni, visitate la Documentazione di ExecuTorch.

Ottimizzazione delle prestazioni

Ottimizzazione delle dimensioni del modello

Per ridurre le dimensioni del modello per la distribuzione:

• Utilizzare i modelli più piccoli: Iniziare con YOLO11n (nano) per ottenere il minimo ingombro.
• Risoluzione di ingresso inferiore: Utilizzare immagini di dimensioni ridotte (ad es, imgsz=320 oppure 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 fornisce un'inferenza ottimizzata CPU .
• Accelerazione hardware: Utilizzare delegati specifici per la piattaforma (ad esempio, CoreML per iOS).
• Elaborazione in batch: Elaborare più immagini quando possibile

Benchmark

Il team di Ultralytics ha effettuato un benchmark dei modelli YOLO11 , confrontando la velocità e la precisione di PyTorch e ExecuTorch.

Risoluzione dei problemi

Problemi comuni

Problema: Python version error

Soluzione: ExecuTorch richiede Python 3.10 o superiore. Aggiornare l'installazione di Python :

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

Problema: Export fails during first run

Soluzione: È possibile che ExecuTorch debba scaricare e compilare i componenti al primo utilizzo. Assicuratevi di avere:

```bash
pip install --upgrade executorch
```

Problema: Import errors for ExecuTorch modules

Soluzione: Assicurarsi che ExecuTorch sia installato correttamente:

```bash
pip install executorch --force-reinstall
```

Per ulteriori informazioni sulla risoluzione dei problemi, visitate Ultralytics GitHub Issues o la documentazione di ExecuTorch.

Riepilogo

L'esportazione dei modelli YOLO11 nel formato ExecuTorch consente una distribuzione efficiente su dispositivi mobili ed edge. Grazie all'integrazione PyTorch, al supporto multipiattaforma e alle prestazioni ottimizzate, ExecuTorch è una scelta eccellente per le applicazioni di IA edge.

Principali risultati:

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

FAQ

Come si esporta un modello YOLO11 in formato ExecuTorch?

Esportare un modello YOLO11 in ExecuTorch utilizzando Python o CLI:

```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
model.export(format="executorch")
```

oppure

```bash
yolo export model=yolo11n.pt format=executorch
```

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

L'esportazione di ExecuTorch richiede:

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

Nota: durante la prima esportazione, ExecuTorch scarica e compila automaticamente i componenti necessari, compreso il compilatore FlatBuffers.

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

Modelli ExecuTorch (.pte ) sono progettati per essere distribuiti su dispositivi mobili ed edge utilizzando il runtime ExecuTorch. Non possono essere caricati direttamente con YOLO() per l'inferenza in Python. È necessario integrarli nell'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 colloca ExecuTorch rispetto a TFLite per l'implementazione mobile?

Sia ExecuTorch che TFLite sono eccellenti per la distribuzione mobile:

• ExecuTorch: Migliore integrazione di PyTorch , flusso di lavoro nativo PyTorch , ecosistema in crescita
• TFLite: Più maturo, più ampio supporto hardware, più esempi di implementazione

Scegliete ExecuTorch se state già usando PyTorch e volete un percorso di distribuzione nativo. Scegliete TFLite per ottenere la massima compatibilità e strumenti maturi.

È possibile utilizzare i modelli ExecuTorch con l'accelerazione GPU ?

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

• GPU mobile: Tramite delegati Vulkan, Metal o OpenCL
• NPU/DSP: tramite delegati specifici della piattaforma
• Predefinito: XNNPACK per l'inferenza ottimizzata CPU

Per l'impostazione specifica del backend, consultare la documentazione di ExecuTorch.

📅 Creato 0 giorni fa ✏️ Aggiornato 0 giorni fa

Commenti