Implante YOLO11 em Mobile & Edge com 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. ExecuTorch, a solução da 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 que você implemente seus modelos em dispositivos móveis e de borda com desempenho otimizado.

Por que exportar para ExecuTorch?

ExecuTorch é a solução end-to-end do PyTorch para habilitar recursos 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 em uma ampla variedade de plataformas de computação.

Principais características do ExecuTorch

ExecuTorch oferece vários recursos poderosos para implantar modelos Ultralytics YOLO em dispositivos de ponta:

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

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

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

• Eficiência de Memória: O gerenciamento otimizado de memória reduz a utilizaçã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.) em um arquivo YAML separado para fácil integração.

Opções de Implementação com ExecuTorch

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

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

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

• Dispositivos Edge AI: Implante em hardware Edge AI especializado com delegados personalizados para inferência acelerada.

• Dispositivos IoT: Integre em dispositivos IoT para inferência no dispositivo sem requisitos de conectividade na nuvem.

Exportando Modelos Ultralytics YOLO11 para ExecuTorch

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

Instalação

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

# Install Ultralytics package
pip install ultralytics

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

Utilização

Exportar modelos YOLO11 para ExecuTorch é simples:

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

Argumentos de Exportação

Ao exportar para o formato ExecuTorch, você pode especificar os seguintes argumentos:

Estrutura de Saída

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

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

Usando Modelos ExecuTorch Exportados

Após exportar seu modelo, você precisará integrá-lo em sua aplicação alvo usando o runtime ExecuTorch.

Integração Móvel

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

1. Adicionar ExecuTorch Runtime: Inclua a biblioteca de tempo de execução ExecuTorch em seu projeto móvel
2. Carregar Modelo: Carregue o .pte arquivo em sua aplicação
3. Executar Inferência: Processe imagens e obtenha 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/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);

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/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 Embarcado

Para sistemas Linux embarcados, use a 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});

Para mais detalhes sobre como integrar o ExecuTorch em suas aplicações, visite a Documentação do ExecuTorch.

Otimização de Desempenho

Otimização do Tamanho do Modelo

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

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

Otimização da Velocidade de Inference

Para uma inferência mais rápida:

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

Benchmarks

A equipe Ultralytics fez benchmark de modelos YOLO11, comparando velocidade e precisão entre PyTorch e ExecuTorch.

Resolução de Problemas

Problemas Comuns

Problema: Python version error

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

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

Problema: Export fails during first run

Solução: O ExecuTorch pode precisar de descarregar e compilar componentes na primeira utilização. Certifique-se de que tem:

pip install --upgrade executorch

Problema: Import errors for ExecuTorch modules

Solução: Certifique-se de que o ExecuTorch está instalado corretamente:

pip install executorch --force-reinstall

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

Resumo

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

Principais conclusões:

• ExecuTorch fornece implantação de ponta nativa do PyTorch com excelente desempenho
• A exportação é simples com format='executorch' parâmetro
• 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 compilador FlatBuffers

FAQ

Como exporto um modelo YOLO11 para o formato ExecuTorch?

Exporte um modelo YOLO11 para ExecuTorch usando Python ou CLI:

from ultralytics import YOLO

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

ou

yolo export model=yolo11n.pt format=executorch

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

A exportação para ExecuTorch requer:

• Python 3.10 ou superior
• executorch pacote (instale via pip install executorch)
• PyTorch (instalado automaticamente com ultralytics)

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

Posso executar inferência com modelos ExecuTorch diretamente em python?

Modelos ExecuTorch (.pte arquivos) são projetados para implantação em dispositivos móveis e de borda usando o runtime ExecuTorch. Eles não podem ser carregados diretamente com YOLO() para inferência em python. Precisa de os integrar na sua aplicação de destino utilizando as bibliotecas de tempo de execução ExecuTorch.

Quais plataformas são suportadas pelo ExecuTorch?

ExecuTorch suporta:

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

Como 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 do PyTorch, ecossistema crescente
• TFLite: Mais maduro, maior suporte de hardware, mais exemplos de implantação

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

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

Sim! O ExecuTorch oferece suporte à aceleração de hardware por meio de vários backends:

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

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

📅 Criado há 1 mês ✏️ Atualizado há 25 dias

Comentários