Link to this sectionImplementa o YOLO26 em dispositivos móveis e de borda com o ExecuTorch#

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

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

Link to this sectionPor que exportar para o ExecuTorch?#

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

Link to this sectionPrincipais características do ExecuTorch#

O ExecuTorch oferece vários recursos poderosos para a implementação de modelos Ultralytics YOLO em dispositivos de borda:

• 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 padrão com o XNNPACK oferece inferência altamente otimizada em CPUs móveis, proporcionando um excelente desempenho sem a necessidade de hardware especializado.

• Pronto 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; o Ultralytics atualmente exporta modelos FP32 através do backend XNNPACK.

• Eficiência de Memória: O gerenciamento de memória otimizado reduz a ocupação 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 arquivo YAML separado para facilitar a integração.

Link to this sectionOpções de Implementação com o ExecuTorch#

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

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

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

• Dispositivos de Borda com IA: Implementa em hardware de IA de borda especializado com delegados personalizados para inferência acelerada.

• Dispositivos IoT: Integra em dispositivos IoT para inferência no dispositivo sem a necessidade de conectividade com a nuvem.

Link to this sectionExportando Modelos Ultralytics YOLO26 para o ExecuTorch#

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

Link to this sectionInstalação#

A exportação para o ExecuTorch requer Python 3.10-3.13 e PyTorch >= 2.9.0 juntamente com o pacote executorch:

# Install Ultralytics package
pip install ultralytics

Para instruções detalhadas e melhores práticas relacionadas ao processo de instalação, confere o nosso Guia de Instalação do YOLO26. Ao instalar os pacotes necessários para o YOLO26, caso encontres alguma dificuldade, consulta o nosso Guia de Problemas Comuns para soluções e dicas.

Link to this sectionUso#

Exportar modelos YOLO26 para o ExecuTorch é simples:

O formato ExecuTorch suporta os modos Export, Predict e Validate. 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")

Link to this sectionArgumentos de Exportação#

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

Link to this sectionEstrutura de Saída#

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

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

Link to this sectionUsando Modelos ExecuTorch Exportados#

Após exportares o teu modelo, precisarás de integrá-lo na tua aplicação de destino usando o runtime do ExecuTorch.

Link to this sectionIntegração Móvel#

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

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

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

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

Para sistemas Linux embarcados, usa 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 mais detalhes sobre a integração do ExecuTorch nas tuas aplicações, visita a Documentação do ExecuTorch.

Link to this sectionOtimização de Desempenho#

Link to this sectionOtimização do Tamanho do Modelo#

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

• Usar Modelos Menores: Começa com o YOLO26n (nano) para a menor ocupação
• Reduzir 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 versões futuras do ExecuTorch)

Link to this sectionOtimização da Velocidade de Inferência#

Para uma inferência mais rápida:

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

Link to this sectionBenchmarks#

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

Link to this sectionSolução de Problemas#

Link to this sectionProblemas Comuns#

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

Problema: Export fails during first run

Solução: Garante que tens a última versão do executorch wheel pré-compilado instalada:

pip install --upgrade executorch

Problema: Import errors for ExecuTorch modules

Solução: Garante que o ExecuTorch está corretamente instalado:

pip install executorch --force-reinstall

Para obter mais ajuda sobre resolução de problemas, visita as Questões do GitHub da Ultralytics ou a Documentação do ExecuTorch.

Link to this sectionResumo#

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

Principais pontos:

• O ExecuTorch fornece implementação de borda nativa do 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 embarcado
• Requer Python 3.10-3.13 e PyTorch >= 2.9.0

Link to this sectionFAQ#

Link to this sectionComo posso exportar um modelo YOLO26 para o formato ExecuTorch?#

Exporta um modelo YOLO26 para o 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

Link to this sectionQuais são os requisitos de sistema para a exportação do 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: O pacote executorch inclui wheels pré-compilados (com o backend XNNPACK), portanto, não é necessário nenhum passo de compilação adicional durante a exportação.

Link to this sectionPosso executar a inferência com modelos ExecuTorch diretamente em Python?#

Os modelos ExecuTorch podem ser carregados diretamente com o YOLO() para inferência e validação em Python (vê os exemplos de Predict/Validate acima), e também podem ser implementados em dispositivos móveis e de borda usando as bibliotecas de runtime do ExecuTorch.

Link to this sectionQuais plataformas são suportadas pelo ExecuTorch?#

O ExecuTorch suporta:

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

Link to this sectionComo o ExecuTorch se compara ao TFLite para implantação móvel?#

Tanto o ExecuTorch quanto o TFLite são excelentes para implantação móvel:

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

Escolha o ExecuTorch se você já está usando PyTorch e deseja um caminho de implantação nativo. Escolha o TFLite para compatibilidade máxima e ferramentas maduras.

Link to this sectionPosso usar modelos do 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

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