Implemente YOLO26 em dispositivos móveis e de edge com ExecuTorch#

A implementação de modelos de visão computacional em dispositivos de edge, como smartphones, tablets e sistemas integrados, exige um runtime otimizado que equilibre o desempenho com as restrições de recursos. O ExecuTorch, a solução da PyTorch para computação de edge, permite a inferência eficiente no dispositivo para modelos Ultralytics YOLO.

Este guia explica como exportar modelos Ultralytics YOLO para o formato ExecuTorch, permitindo implementar os teus modelos em dispositivos móveis e de edge com desempenho otimizado.

Porquê exportar para ExecuTorch?#

O ExecuTorch é a solução completa da PyTorch para ativar capacidades de inferência no dispositivo em dispositivos móveis e de edge. Desenvolvido para ser portátil e eficiente, o ExecuTorch pode ser utilizado para executar programas PyTorch numa grande variedade de plataformas computacionais.

Principais funcionalidades do ExecuTorch#

O ExecuTorch oferece várias funcionalidades avançadas para implementar modelos Ultralytics YOLO em dispositivos de edge:

• Formato de modelo portátil: o ExecuTorch utiliza o formato .pte (PyTorch ExecuTorch), otimizado para reduzir o tamanho e acelerar o carregamento em dispositivos com recursos limitados.

• Backend XNNPACK: a integração predefinida com XNNPACK proporciona inferência altamente otimizada em CPUs móveis, oferecendo excelente desempenho sem exigir hardware especializado.

• Preparado para quantização: o ecossistema ExecuTorch suporta técnicas de quantização para reduzir o tamanho do modelo e melhorar a velocidade de inferência; atualmente, o Ultralytics exporta modelos FP32 através do backend XNNPACK.

• Eficiência de memória: a gestão de memória otimizada reduz a utilização de memória em runtime, tornando-o adequado para dispositivos com RAM limitada.

• Metadados do modelo: os modelos exportados incluem metadados (tamanho da imagem, nomes das classes, etc.) num ficheiro YAML separado para facilitar a integração.

Opções de implementação com ExecuTorch#

Os modelos ExecuTorch podem ser implementados em várias plataformas de edge e móveis:

• Aplicações móveis: implementa em aplicações iOS e Android com desempenho nativo, permitindo a deteção de objetos em tempo real em aplicações móveis.

• Sistemas integrados: executa em dispositivos Linux integrados, como Raspberry Pi, NVIDIA Jetson e outros sistemas baseados em ARM, com desempenho otimizado.

• Dispositivos de IA de edge: implementa em hardware especializado de IA de edge com delegates personalizados para acelerar a inferência.

• Dispositivos IoT: integra em dispositivos IoT para realizar inferência no dispositivo sem exigir conectividade à cloud.

Tarefas suportadas#

A exportação para ExecuTorch suporta todas as sete tarefas do Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas com YOLO26, a única família que inclui essas heads.

Exportar modelos Ultralytics YOLO26 para ExecuTorch#

A conversão de modelos Ultralytics YOLO26 para o formato ExecuTorch permite uma implementação eficiente em dispositivos móveis e de edge.

Instalação#

A exportação para ExecuTorch requer Python 3.10-3.13 e PyTorch >= 2.9.0, além do pacote executorch:

# Install Ultralytics package
pip install ultralytics

Para obter instruções detalhadas e boas práticas relacionadas com o processo de instalação, consulta o nosso guia de instalação do YOLO26. Durante a instalação dos pacotes necessários para YOLO26, se encontrares alguma dificuldade, consulta o nosso guia de problemas comuns para obter soluções e sugestões.

Utilização#

A exportação de modelos YOLO26 para ExecuTorch é simples:

O formato ExecuTorch suporta os modos Exportar, Prever e Validar. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar a inferência ou validar a sua precisão.

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")

Argumentos de Exportação#

Ao exportar para o formato ExecuTorch, podes especificar os seguintes argumentos:

Estrutura de Saída#

A exportação para ExecuTorch cria um diretório que contém o modelo e os metadados:

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

Utilizar modelos ExecuTorch exportados#

Depois de exportares o teu modelo, terás de o integrar na aplicação de destino utilizando o runtime ExecuTorch.

Integração móvel#

Para aplicações móveis (iOS/Android), terás de:

1. Adicionar o runtime ExecuTorch: inclui a biblioteca de runtime ExecuTorch no teu projeto móvel
2. Carregar o modelo: carrega o ficheiro .pte na tua aplicação
3. Executar a inferência: processa imagens e obtém previsões

iOS#

Exemplo de integração com 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);

Android#

Adiciona o AAR do ExecuTorch para Android a partir do Maven Central:

dependencies {
    implementation("org.pytorch:executorch-android:<version>")
}

Exemplo de integração com 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

Linux integrado#

Para sistemas Linux integrados, utiliza a API C++ do 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);

Para obter mais informações sobre a integração do ExecuTorch nas tuas aplicações, visita a documentação do ExecuTorch.

Otimização do desempenho#

Otimização do tamanho do modelo#

Para reduzir o tamanho do modelo durante a implementação:

• Utiliza modelos mais pequenos: começa com YOLO26n (nano) para obter a menor utilização de recursos
• Reduz a resolução de entrada: utiliza tamanhos de imagem mais pequenos (por exemplo, imgsz=320 ou imgsz=416)
• Quantização: aplica técnicas de quantização (suportadas em versões futuras do ExecuTorch)

Otimização da velocidade de inferência#

Para uma inferência mais rápida:

• Backend XNNPACK: o backend XNNPACK predefinido proporciona inferência otimizada na CPU
• Aceleração de hardware: utiliza delegates específicos da plataforma (por exemplo, CoreML para iOS)
• Processamento em lotes: processa várias imagens quando possível

Benchmarks#

A equipa do Ultralytics avaliou modelos YOLO26, comparando a velocidade e a precisão entre PyTorch e ExecuTorch.

Resolução de problemas#

Problemas comuns#

Problema: Python version error

Solução: O ExecuTorch requer o Python 3.10 a 3.13. Cria um ambiente com uma versão suportada:

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

Problema: Export fails during first run

Solução: certifica-te de que tens instalado o wheel pré-compilado mais recente executorch:

pip install --upgrade executorch

Problema: Import errors for ExecuTorch modules

Solução: certifica-te de que o ExecuTorch está instalado corretamente:

pip install executorch --force-reinstall

Para obter mais ajuda na resolução de problemas, visita os problemas do Ultralytics no GitHub ou a documentação do ExecuTorch.

Resumo#

A exportação de modelos YOLO26 para o formato ExecuTorch permite uma implementação eficiente em dispositivos móveis e de edge. Com integração nativa com PyTorch, suporte multiplataforma e desempenho otimizado, o ExecuTorch é uma excelente opção para aplicações de IA de edge.

Principais conclusões:

• O ExecuTorch oferece implementação de edge nativa para PyTorch com excelente desempenho
• A exportação é simples com o parâmetro format='executorch'
• Os modelos são otimizados para CPUs móveis através do backend XNNPACK
• Suporta plataformas iOS, Android e Linux integrado
• Requer Python 3.10-3.13 e PyTorch >= 2.9.0

Perguntas frequentes#