Distribuisci YOLO11 su Mobile & Edge con ExecuTorch

La distribuzione 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, consente un'inferenza efficiente sul dispositivo per i modelli Ultralytics YOLO.

Questa guida descrive come esportare i modelli Ultralytics YOLO in formato ExecuTorch, consentendoti 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 portatile 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 la distribuzione di modelli Ultralytics YOLO su dispositivi edge:

• Formato modello portatile: ExecuTorch utilizza .pte formato (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 alla quantizzazione: Supporto integrato per le tecniche di quantizzazione per ridurre le dimensioni del modello e migliorare la velocità di inferenza, mantenendo al contempo l'accuratezza.

• Efficienza della memoria: La gestione ottimizzata della memoria riduce l'impronta di memoria in fase di 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 implementazione con ExecuTorch

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

• Applicazioni Mobile: Esegui il deployment su applicazioni iOS e Android con prestazioni native, consentendo il detect di oggetti in tempo reale nelle app mobile.

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

• Dispositivi Edge AI: Esegui il deployment su hardware Edge AI specializzato con delegati personalizzati per l'inferenza accelerata.

• Dispositivi IoT: Integrazione in dispositivi IoT per l'inferenza on-device senza requisiti di connettività cloud.

Esportazione di modelli Ultralytics YOLO11 in ExecuTorch

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

Installazione

L'export con 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 di 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 dell'output

L'export 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 di modelli ExecuTorch esportati

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

Integrazione mobile

Per applicazioni mobile (iOS/Android), sarà necessario:

1. Aggiungi ExecuTorch Runtime: Includi la libreria di runtime ExecuTorch nel tuo progetto mobile
2. Carica modello: Carica il .pte file nella tua applicazione
3. Esegui Inferenza: Elabora le immagini e ottieni le 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/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 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 Embedded

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

Ottimizzazione delle performance

Ottimizzazione della dimensione del modello

Per ridurre le dimensioni del modello per la distribuzione:

• Usa modelli più piccoli: Inizia con YOLO11n (nano) per l'impronta più piccola
• Risoluzione di input inferiore: Utilizzare dimensioni dell'immagine più piccole (ad es. imgsz=320 oppure imgsz=416)
• Quantizzazione: Applica tecniche di quantizzazione (supportate nelle future versioni di ExecuTorch)

Ottimizzazione della velocità di Inference

Per un'inferenza più rapida:

• Backend XNNPACK: Il backend XNNPACK predefinito fornisce un'inferenza CPU ottimizzata
• Accelerazione hardware: Utilizza delegati specifici della piattaforma (ad esempio, CoreML per iOS)
• Elaborazione batch: Elabora più immagini quando possibile

Benchmark

Il team di Ultralytics ha eseguito il benchmark dei modelli YOLO11, 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: ExecuTorch potrebbe aver bisogno di 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 nella risoluzione dei problemi, visitare le segnalazioni dei problemi di Ultralytics su GitHub o la documentazione di ExecuTorch.

Riepilogo

L'esportazione di modelli YOLO11 in formato ExecuTorch consente una distribuzione efficiente su dispositivi mobili e edge. Con l'integrazione nativa di PyTorch, il supporto cross-platform e le prestazioni ottimizzate, ExecuTorch è una scelta eccellente per le applicazioni di edge AI.

Punti chiave:

• ExecuTorch fornisce una distribuzione edge nativa di PyTorch con prestazioni eccellenti
• L'esportazione è semplice con format='executorch' parametro
• I modelli sono ottimizzati per le CPU mobili 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 YOLO11 nel formato ExecuTorch?

Esporta un modello YOLO11 in ExecuTorch usando Python o la CLI:

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="executorch")

oppure

yolo export model=yolo11n.pt format=executorch

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

L'export con ExecuTorch richiede:

• Python 3.10 o superiore
• executorch pacchetto (installare 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 modelli ExecuTorch direttamente in python?

Modelli ExecuTorch (.pte file) sono progettati per essere distribuiti su dispositivi mobili e 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 di runtime ExecuTorch.

Quali piattaforme sono supportate da ExecuTorch?

ExecuTorch supporta:

• Mobile: iOS e Android
• Embedded Linux: 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 su dispositivi mobili?

Sia ExecuTorch che TFLite sono eccellenti per l'implementazione mobile:

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

Scegli ExecuTorch se stai già utilizzando PyTorch e desideri un percorso di deployment nativo. Scegli TFLite per la massima compatibilità e strumenti consolidati.

Posso utilizzare modelli ExecuTorch con 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 su CPU

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

📅 Creato 1 mese fa ✏️ Aggiornato 25 giorni fa

Commenti