Implementa o YOLO26 em Dispositivos Móveis e Edge com ExecuTorch

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

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

Porquê exportar para o ExecuTorch?

O ExecuTorch é a solução ponta a ponta do PyTorch para ativar capacidades de inferência no dispositivo em equipamentos móveis e edge. Construído com o objetivo de ser portátil e eficiente, o ExecuTorch pode ser usado para executar programas PyTorch numa grande variedade de plataformas computacionais.

Principais funcionalidades do ExecuTorch

O ExecuTorch oferece várias funcionalidades poderosas para implementar modelos Ultralytics YOLO em dispositivos edge:

• Formato de Modelo Portátil: O ExecuTorch utiliza o formato .pte (PyTorch ExecuTorch), que é otimizado para tamanho e velocidade de carregamento em dispositivos com recursos limitados.

• Backend XNNPACK: A integração por omissão com o XNNPACK oferece uma inferência altamente otimizada em CPUs móveis, proporcionando um excelente desempenho sem exigir hardware especializado.

• Suporte a Quantização: Suporte integrado para técnicas de quantização, visando reduzir o tamanho do modelo e melhorar a velocidade de inferência, mantendo a precisão.

• Eficiência de Memória: A gestão de memória otimizada reduz a pegada de memória em tempo de execução, 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 o ExecuTorch

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

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

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

• Dispositivos Edge AI: Implementa em hardware de IA edge especializado com delegados personalizados para inferência acelerada.

• Dispositivos IoT: Integra em dispositivos IoT para inferência no próprio dispositivo, sem requisitos de conectividade na nuvem.

Exportar Modelos Ultralytics YOLO26 para o ExecuTorch

Converter modelos Ultralytics YOLO26 para o formato ExecuTorch possibilita uma implementação eficiente em dispositivos móveis e edge.

Instalação

A exportação para o ExecuTorch requer Python 3.10 ou superior e dependências específicas:

# Install Ultralytics package
pip install ultralytics

Para instruções detalhadas e práticas recomendadas relacionadas ao processo de instalação, consulte nosso guia de Instalação YOLO26. Ao instalar os pacotes necessários para o YOLO26, se você encontrar alguma dificuldade, consulte nosso guia de Problemas Comuns para soluções e dicas.

Utilização

Exportar modelos YOLO26 para o ExecuTorch é simples:

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

Argumentos de Exportação

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

Estrutura de Saída

A exportação para o ExecuTorch cria um diretório contendo o modelo e os metadados:

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

Usar Modelos ExecuTorch Exportados

Após exportares o teu modelo, precisas de o integrar na tua aplicação alvo usando o runtime do ExecuTorch.

Integração Móvel

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

1. Adicionar Runtime do ExecuTorch: Inclui a biblioteca do runtime do ExecuTorch no teu projeto móvel
2. Carregar Modelo: Carrega o ficheiro .pte na tua aplicação
3. Executar Inferência: Processa imagens e obtém predições

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

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

Para sistemas Linux embarcados, usa a API C++ do 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});

Para mais detalhes sobre a integração do ExecuTorch nas tuas aplicações, visita a Documentação do ExecuTorch.

Otimização de Desempenho

Otimização do Tamanho do Modelo

Para reduzir o tamanho do modelo para implementação:

• Usa Modelos Menores: Começa com o YOLO26n (nano) para a menor pegada
• Reduz a Resolução de Entrada: Usa tamanhos de imagem menores (por exemplo, imgsz=320 ou imgsz=416)
• Quantização: Aplica técnicas de quantização (suportadas em futuras versões do ExecuTorch)

Otimização da Velocidade de Inferência

Para uma inferência mais rápida:

• Backend XNNPACK: O backend XNNPACK padrão oferece inferência de CPU otimizada
• Aceleração de Hardware: Usa delegados específicos da plataforma (por exemplo, CoreML para iOS)
• Processamento em Lote: Processa múltiplas imagens quando possível

Benchmarks

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

Resolução de Problemas

Problemas Comuns

Issue: Python version error

Solução: O ExecuTorch requer Python 3.10 ou superior. Atualiza a tua instalação do Python:

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

Issue: Export fails during first run

Solução: O ExecuTorch pode precisar de descarregar e compilar componentes na primeira utilização. Certifica-te de que tens:

pip install --upgrade executorch

Issue: Import errors for ExecuTorch modules

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

pip install executorch --force-reinstall

Para mais ajuda na resolução de problemas, visita as GitHub Issues da Ultralytics ou a Documentação do ExecuTorch.

Resumo

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

Principais conclusões:

• O ExecuTorch oferece implementação edge nativa com PyTorch e 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 embarcado
• Requer Python 3.10+ e o compilador FlatBuffers

FAQ

Como posso exportar um modelo YOLO26 para o formato ExecuTorch?

Exporta um modelo YOLO26 para ExecuTorch usando Python ou CLI:

from ultralytics import YOLO

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

ou

yolo export model=yolo26n.pt format=executorch

Quais são os requisitos do sistema para a exportação para o ExecuTorch?

A exportação para o ExecuTorch requer:

• Python 3.10 ou superior
• Pacote executorch (instala via pip install executorch)
• PyTorch (instalado automaticamente com o ultralytics)

Nota: Durante a primeira exportação, o ExecuTorch descarregará e compilará automaticamente os componentes necessários, incluindo o compilador FlatBuffers.

Posso executar a inferência com modelos ExecuTorch diretamente em Python?

Os modelos ExecuTorch (ficheiros .pte) são concebidos para implementação em dispositivos móveis e edge usando o runtime do ExecuTorch. Não podem ser carregados diretamente com o YOLO() para inferência em Python. Precisas de integrá-los na tua aplicação alvo usando as bibliotecas do runtime do ExecuTorch.

Que plataformas são suportadas pelo ExecuTorch?

O ExecuTorch suporta:

• Móvel: iOS e Android
• Linux Embarcado: Raspberry Pi, NVIDIA Jetson e outros dispositivos ARM
• Desktop: Linux, macOS e Windows (para desenvolvimento)

Como é que o ExecuTorch se compara ao TFLite para implementação móvel?

Tanto o ExecuTorch como o TFLite são excelentes para implementação móvel:

• ExecuTorch: Melhor integração com PyTorch, fluxo de trabalho nativo PyTorch, ecossistema em crescimento
• TFLite: Mais maduro, maior suporte de hardware, mais exemplos de implementação

Escolhe o ExecuTorch se já usas PyTorch e queres um caminho de implementação nativo. Escolhe o TFLite para máxima compatibilidade e ferramentas maduras.

Posso usar modelos ExecuTorch com aceleração de GPU?

Sim! O ExecuTorch suporta aceleração de hardware através de vários backends:

• GPU Móvel: Via delegados Vulkan, Metal ou OpenCL
• NPU/DSP: Via delegados específicos da plataforma
• Padrão: XNNPACK para inferência de CPU otimizada

Consulta a Documentação do ExecuTorch para a configuração específica do backend.