Implementar YOLO11 no telemóvel e no Edge com o ExecuTorch

A implementação de modelos de visão computacional em dispositivos de ponta, como smartphones, tablets e sistemas incorporados, requer um tempo de execução optimizado que equilibre o desempenho com as restrições de recursos. ExecuTorch, a solução da PyTorch para computação de ponta, permite inferência eficiente no dispositivo para Ultralytics YOLO do Ultralytics.

Este guia descreve como exportar modelos Ultralytics YOLO para o formato ExecuTorch, permitindo-lhe implementar os seus modelos em dispositivos móveis e de ponta com um desempenho optimizado.

Porquê exportar para o ExecuTorch?

O ExecuTorch é a solução completa do PyTorch para permitir recursos de inferência no dispositivo em dispositivos móveis e de ponta. 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 caraterísticas do ExecuTorch

O ExecuTorch fornece vários recursos poderosos para a implantação de modelosYOLO Ultralytics em dispositivos de borda:

• Formato de modelo portátil: O ExecuTorch utiliza o .pte PyTorch ExecuTorch), que é optimizado para o tamanho e velocidade de carregamento em dispositivos com recursos limitados.

• Backend XNNPACK: A integração padrão com o XNNPACK fornece inferência altamente otimizada em CPUs móveis, oferecendo excelente desempenho sem a necessidade de 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: A gestão optimizada da memória reduz o espaç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 de classes, etc.) num ficheiro YAML separado para facilitar a integração.

Opções de implantação com o ExecuTorch

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

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

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

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

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

Exportação de modelosYOLO11 Ultralytics para o ExecuTorch

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

Instalação

A exportação do 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

A exportação de modelos YOLO11 para o 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, é possível especificar os seguintes argumentos:

Estrutura de saída

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

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

Utilização de modelos ExecuTorch exportados

Depois de exportar o seu modelo, terá de o integrar na sua aplicação de destino utilizando o tempo de execução do ExecuTorch.

Integração móvel

Para aplicações móveisiOSAndroid), é necessário:

1. Adicione o tempo de execução do ExecuTorch: Incluir a biblioteca de tempo de execução do ExecuTorch no seu projeto móvel
2. Modelo de carga: Carregar o .pte na sua aplicação
3. Executar inferência: Processar imagens e obter previsõ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 incorporado

Para sistemas Linux incorporados, utilize a API C++ do ExecuTorch:

#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 obter mais detalhes sobre a integração do ExecuTorch em seus aplicativos, visite a Documentação do ExecuTorch.

Otimização do desempenho

Otimização do tamanho do modelo

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

• Utilizar modelos mais pequenos: Comece com o YOLO11n (nano) para obter a pegada mais pequena
• Resolução de entrada inferior: Utilize tamanhos de imagem mais pequenos (por exemplo, imgsz=320 ou imgsz=416)
• Quantização: Aplicar 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:

• XNNPACK Backend: O backend padrão do XNNPACK fornece inferência otimizada CPU
• Aceleração de hardware: Utilizar delegados específicos da plataforma (por exemplo, CoreML para iOS)
• Processamento em lote: Processar várias imagens sempre que possível

Benchmarks

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

Resolução de Problemas

Problemas Comuns

Problema: Python version error

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

```bash
# 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 ter:

```bash
pip install --upgrade executorch
```

Problema: Import errors for ExecuTorch modules

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

```bash
pip install executorch --force-reinstall
```

Para obter mais ajuda na solução de problemas, visite os Problemas doUltralytics no GitHub ou a Documentação do ExecuTorch.

Resumo

A exportação de modelos YOLO11 para o formato ExecuTorch permite a implantação eficiente em dispositivos móveis e de borda. Com a integração PyTorch, suporte multiplataforma e desempenho otimizado, o ExecuTorch é uma excelente escolha para aplicativos de IA de ponta.

Principais conclusões:

• O ExecuTorch fornece uma implantação de borda PyTorch com excelente desempenho
• A exportação é simples com format='executorch' parâmetro
• Os modelos são optimizados para CPUs móveis através do backend XNNPACK
• Compatível com iOS, Android e plataformas Linux incorporadas
• Requer Python 3.10+ e compilador FlatBuffers

FAQ

Como é que exporto um modelo YOLO11 para o formato ExecuTorch?

Exportar um modelo YOLO11 para o ExecuTorch utilizando Python ou CLI:

```python
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
model.export(format="executorch")
```

ou

```bash
yolo export model=yolo11n.pt format=executorch
```

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

A exportação do ExecuTorch requer:

• Python 3.10 ou superior
• executorch (instalar 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 efetuar inferência com modelos ExecuTorch diretamente em Python?

Modelos ExecuTorch (.pte ) foram concebidos para serem implementados em dispositivos móveis e periféricos utilizando o tempo de execução do ExecuTorch. Não podem ser carregados diretamente com YOLO() para inferência em Python. É necessário integrá-las na sua aplicação de destino utilizando as bibliotecas de tempo de execução do ExecuTorch.

Que plataformas são suportadas pelo ExecuTorch?

O ExecuTorch suporta:

• Telemóvel: iOS e Android
• Linux incorporado: Raspberry Pi, NVIDIA Jetson e outros dispositivos ARM
• Ambiente de trabalho: Linux, macOS e Windows (para desenvolvimento)

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

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

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

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

Posso utilizar modelos ExecuTorch com aceleração GPU ?

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

• GPU móvel: Via Vulkan, Metal ou delegados OpenCL
• NPU/DSP: Através de delegados específicos da plataforma
• Predefinição: XNNPACK para inferência optimizada CPU

Consulte a documentação do ExecuTorch para obter informações sobre a configuração específica do backend.

📅 Criado há 0 dias ✏️ Atualizado há 0 dias

Comentários