Implante modelos Ultralytics YOLO usando a integração do ExecuTorch

Algumas aplicações de visão computacional, como inspeção automatizada de qualidade, drones autônomos ou sistemas de segurança inteligentes, têm melhor desempenho quando os modelos Ultralytics YOLO, como o Ultralytics YOLO11, são executados perto do sensor que captura as imagens. Em outras palavras, esses modelos precisam processar dados diretamente onde são gerados — em câmeras, drones ou sistemas embarcados — em vez de enviá-los para a nuvem.

Essa abordagem, conhecida como IA de borda, permite que os modelos façam inferência diretamente no dispositivo onde os dados são capturados. Ao processar as informações localmente, em vez de depender de servidores remotos, os sistemas podem reduzir a latência, aumentar a privacidade dos dados e oferecer maior confiabilidade, mesmo em ambientes com conectividade limitada ou sem internet.

Por exemplo, uma câmera de manufatura que inspeciona milhares de produtos por minuto ou um drone que navega por ambientes complexos não pode se dar ao luxo dos atrasos causados pelo processamento na nuvem. Executar o Ultralytics YOLO11 diretamente no dispositivo permite fazer inferências instantâneas no próprio dispositivo.

Para facilitar e tornar mais eficiente a execução de modelos Ultralytics YOLO na borda, a nova integração com ExecuTorch, disponibilizada pela Ultralytics, oferece uma maneira simplificada de exportar e implantar modelos diretamente em dispositivos móveis e embarcados. O ExecuTorch faz parte do ecossistema PyTorch Edge e oferece uma solução completa para executar modelos de IA diretamente em dispositivos móveis e de borda, incluindo celulares, dispositivos vestíveis, placas embarcadas e microcontroladores.

Essa integração facilita levar um modelo Ultralytics YOLO, como o YOLO11, do treinamento à implantação em dispositivos de borda. Ao combinar os recursos de visão do YOLO11 com o runtime leve do ExecuTorch e o pipeline de exportação do PyTorch, os usuários podem implantar modelos que funcionam com eficiência em hardware de borda, preservando a precisão e o desempenho da inferência baseada em PyTorch.

Neste artigo, vamos analisar mais de perto como funciona a integração com o ExecuTorch, por que ela é uma ótima opção para aplicações de IA de borda e como você pode começar a implantar modelos Ultralytics YOLO com o ExecuTorch.

O que é ExecuTorch?#

Normalmente, quando você treina um modelo no PyTorch, ele é executado em servidores potentes ou em unidades de processamento gráfico (GPUs) na nuvem. No entanto, implantar esse mesmo modelo em um dispositivo móvel ou embarcado, como um smartphone, drone ou microcontrolador, exige uma solução especializada que dê conta do poder de processamento, da memória e da conectividade limitados.

É exatamente isso que o ExecuTorch oferece. O ExecuTorch é uma solução completa desenvolvida como parte do ecossistema PyTorch Edge, que permite fazer inferência com eficiência no próprio dispositivo em plataformas móveis, embarcadas e de borda. Ele amplia os recursos do PyTorch para além da nuvem, permitindo que modelos de IA sejam executados diretamente em dispositivos locais.

Levando a inferência do PyTorch para a borda#

Em sua essência, o ExecuTorch oferece um runtime leve em C++ que permite executar modelos PyTorch diretamente no dispositivo. O ExecuTorch usa o formato de modelo PyTorch ExecuTorch (.pte), uma exportação otimizada para carregamento mais rápido, menor uso de memória e melhor portabilidade.

Ele oferece suporte ao XNNPACK como backend padrão para inferência eficiente na unidade central de processamento (CPU) e amplia a compatibilidade com uma ampla variedade de backends de hardware, incluindo CoreML, Metal, Vulkan, Qualcomm, MediaTek, Arm EthosU, OpenVINO e outros.

Esses backends permitem aceleração otimizada em dispositivos móveis, embarcados e especializados de borda. O ExecuTorch também se integra ao pipeline de exportação do PyTorch, oferecendo suporte a recursos avançados como quantização e tratamento de formas dinâmicas para melhorar o desempenho e a adaptabilidade em diferentes ambientes de implantação.

A quantização reduz o tamanho do modelo e aumenta a velocidade de inferência ao converter valores de alta precisão (como números de ponto flutuante de 32 bits) em valores de menor precisão, enquanto o tratamento de formas dinâmicas permite que os modelos processem com eficiência tamanhos de entrada variáveis. Ambos os recursos são essenciais para executar modelos de IA em dispositivos de borda com recursos limitados.

Fig. 1. Uma visão geral de como o ExecuTorch funciona (Fonte)

Uma camada unificada para hardware de borda#

Além de servir como ambiente de execução, o ExecuTorch também funciona como uma camada de abstração unificada para vários backends de hardware. Em outras palavras, ele abstrai os detalhes específicos do hardware e gerencia a interação dos modelos com diferentes unidades de processamento, incluindo CPUs, GPUs e unidades de processamento neural (NPUs).

Depois que um modelo é exportado, o ExecuTorch pode ser configurado para usar o backend mais adequado para determinado dispositivo. Os desenvolvedores podem implantar modelos com eficiência em diferentes tipos de hardware sem escrever código específico para cada dispositivo nem manter fluxos de conversão separados.

Graças ao design modular e portátil e à integração estreita com o PyTorch, o ExecuTorch é uma ótima opção para implantar modelos de visão computacional como o Ultralytics YOLO11 em sistemas móveis e embarcados. Ele preenche a lacuna entre o treinamento de modelos e a implantação no mundo real, tornando a IA de borda mais rápida, eficiente e fácil de implementar.

Principais recursos do ExecuTorch#

Antes de vermos como exportar modelos Ultralytics YOLO para o formato ExecuTorch, vamos explorar o que torna o ExecuTorch uma opção confiável para implantar IA na borda.

Veja alguns dos principais recursos:

• Suporte à quantização: o ExecuTorch oferece suporte à quantização de modelos, uma técnica que converte valores de alta precisão em valores de menor precisão para reduzir o tamanho do modelo e acelerar a inferência. Isso ajuda os modelos a funcionar mais rápido e usar menos memória em dispositivos de borda, mantendo praticamente o mesmo nível de precisão. Atualmente, a exportação da Ultralytics gera modelos FP32 para o backend XNNPACK.
• Uso eficiente da memória: Uma das maiores vantagens do ExecuTorch é a forma como ele gerencia a memória. Em vez de depender da alocação dinâmica de memória, que pode aumentar a latência e o consumo de energia, o ExecuTorch usa o planejamento de memória antecipado (AOT). Durante a exportação, ele analisa o grafo do modelo e calcula previamente quanta memória cada operação exige. Isso permite que o runtime execute modelos com um plano de memória estático, garantindo um desempenho previsível e evitando lentidão ou falhas em dispositivos com RAM ou capacidade de processamento limitadas.
• Metadados de modelo integrados: Ao exportar usando a integração disponibilizada pela Ultralytics, cada modelo inclui um arquivo YAML com metadados importantes, como o tamanho da imagem de entrada, os nomes das classes e os parâmetros de configuração. Esse arquivo adicional simplifica a integração do modelo em diferentes aplicações e garante um comportamento consistente em várias plataformas de borda.

Como exportar modelos Ultralytics YOLO para o formato ExecuTorch#

Agora que entendemos melhor o que o ExecuTorch oferece, vamos ver como exportar modelos Ultralytics YOLO para o formato ExecuTorch.

Passo 1: Instalar o pacote Python da Ultralytics#

Para começar, você precisa instalar o pacote Python da Ultralytics usando pip, um instalador de pacotes. Para isso, execute “pip install ultralytics” no terminal ou no prompt de comando.

Se você estiver usando um ambiente Jupyter Notebook ou Google Colab, basta adicionar um ponto de exclamação antes do comando, assim: "!pip install ultralytics". Depois de instalado, o pacote Ultralytics oferece todas as ferramentas necessárias para treinar, testar e exportar modelos de visão computacional, incluindo o Ultralytics YOLO11.

Se tiver algum problema durante a instalação ou a exportação do modelo, a documentação oficial da Ultralytics e o guia de problemas comuns oferecem etapas detalhadas para solução de problemas e práticas recomendadas para ajudar você a começar sem dificuldades.

Etapa 2: exportar o Ultralytics YOLO11#

Depois de instalar o pacote Ultralytics, você pode carregar uma variante do modelo YOLO11 e exportá-la para o formato ExecuTorch. Por exemplo, você pode usar um modelo pré-treinado como “yolo11n.pt” e exportá-lo chamando a função de exportação com o formato definido como “executorch”.

Isso cria um diretório chamado “yolo11n_executorch_model”, que inclui o arquivo do modelo otimizado (.pte) e um arquivo YAML separado com metadados contendo detalhes importantes, como o tamanho da imagem e os nomes das classes.

Veja o código para exportar seu modelo:

from ultralytics import YOLO

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

Etapa 3: Executar inferências após exportar o modelo#

Após a exportação, o modelo está pronto para ser implantado em dispositivos móveis e de borda usando o runtime ExecuTorch. O arquivo do modelo .pte exportado pode ser carregado na sua aplicação para executar inferências em tempo real no próprio dispositivo, sem precisar de conexão com a nuvem.

Por exemplo, o trecho de código abaixo mostra como carregar o modelo exportado e executar a inferência. Inferência significa simplesmente usar um modelo treinado para fazer previsões com novos dados. Neste caso, o modelo é testado em uma imagem de um ônibus obtida em um URL público.

executorch_model = YOLO("yolo11n_executorch_model")
results = executorch_model.predict("https://ultralytics.com/images/bus.jpg", save=True)

Depois de executar o código, você encontrará a imagem de saída com os objetos detectados na pasta “runs/detect/predict”.

Fig. 2. Detecção de objetos usando um modelo Ultralytics YOLO11 exportado no formato ExecuTorch.

Vantagens de usar a integração com ExecuTorch#

Ao explorar as diferentes opções de exportação disponibilizadas pela Ultralytics, você pode se perguntar o que torna única a integração com ExecuTorch. A principal diferença está na combinação de desempenho, simplicidade e flexibilidade, que facilita a implantação de modelos de IA poderosos diretamente em dispositivos móveis e de borda.

Veja algumas das principais vantagens de usar a integração com ExecuTorch:

• Opções flexíveis de implantação: Os modelos ExecuTorch podem ser implantados em aplicações móveis, sistemas embarcados, dispositivos de IoT (Internet das Coisas) e hardware especializado de IA de borda. Essa flexibilidade permite que os desenvolvedores criem soluções de IA escaláveis, com desempenho consistente em diversas plataformas e ambientes.
• Desempenho comprovado por benchmarks: Testes em dispositivos como o Raspberry Pi 5 mostram que os modelos Ultralytics YOLO11 exportados para o formato ExecuTorch são aproximadamente 2x mais rápidos que os equivalentes em PyTorch, com precisão praticamente idêntica.
• APIs de integração flexíveis: O ExecuTorch oferece APIs em C++, Kotlin e Objective-C para iOS, Android e Linux embarcado, permitindo que os desenvolvedores integrem modelos YOLO diretamente em aplicações nativas.
• Suporte à aceleração por hardware: O ExecuTorch oferece suporte a vários backends de aceleração por hardware, incluindo Vulkan e Metal para GPUs móveis, com integração opcional para OpenCL e outras APIs específicas de fornecedores. Ele também pode aproveitar aceleradores dedicados, como NPUs e DSPs, para obter ganhos substanciais de velocidade em comparação com a inferência executada somente na CPU.

Aplicações reais do Ultralytics YOLO11 e da exportação para ExecuTorch#

Recentemente, a Ultralytics foi reconhecida como um caso de sucesso do PyTorch ExecuTorch, destacando nosso suporte inicial à inferência no próprio dispositivo e nossas contribuições contínuas para o ecossistema PyTorch. Esse reconhecimento reflete o objetivo comum de tornar a IA de alto desempenho mais acessível em plataformas móveis e de borda.

Da nuvem à borda: como o ExecuTorch e o Ultralytics YOLO11 dão vida à IA de visão#

Na prática, isso significa soluções reais de IA de visão que funcionam com eficiência em tudo, de smartphones a sistemas embarcados. Por exemplo, na manufatura, os dispositivos de borda desempenham um papel fundamental no monitoramento das linhas de produção e na detecção de defeitos em tempo real.

Fig. 3. Exemplo de uso do Ultralytics YOLO11 para analisar uma linha de montagem industrial. (Fonte)

Em vez de enviar imagens ou dados de sensores para a nuvem para processamento, o que pode causar atrasos e depender da conexão com a internet, a integração com ExecuTorch permite que os modelos Ultralytics YOLO sejam executados diretamente no hardware local. Isso significa que as fábricas podem detectar problemas de qualidade imediatamente, reduzir o tempo de inatividade e manter a privacidade dos dados, mesmo operando com recursos computacionais limitados.

Veja alguns outros exemplos de como a integração com ExecuTorch e os modelos Ultralytics YOLO podem ser usados:

• Cidades inteligentes: Ao executar modelos Ultralytics YOLO localmente com o ExecuTorch, as cidades podem tomar decisões mais rápidas e baseadas em dados, desde detectar congestionamentos até identificar perigos, melhorando a mobilidade e a segurança em geral.
• Varejo e armazenagem: Com a inferência no próprio dispositivo, os varejistas podem automatizar o monitoramento de prateleiras, rastrear o estoque e inspecionar pacotes com rapidez e segurança, sem depender de conexões com a nuvem.
• Robótica e drones: Os modelos Ultralytics YOLO otimizados para dispositivos de borda permitem que robôs e drones reconheçam objetos, naveguem por ambientes e tomem decisões em tempo real, mesmo sem acesso à internet.

Fig. 4. Detecção e contagem de carros no trânsito usando o YOLO11 (Fonte)

Principais conclusões#

Exportar modelos Ultralytics YOLO para o formato ExecuTorch facilita a implantação de modelos de visão computacional em muitos dispositivos, incluindo smartphones, tablets e sistemas embarcados, como o Raspberry Pi. Isso permite executar inferências otimizadas no próprio dispositivo sem depender de uma conexão com a nuvem, melhorando a velocidade, a privacidade e a confiabilidade.

Além do ExecuTorch, a Ultralytics oferece suporte a uma ampla variedade de integrações, incluindo TensorRT, OpenVINO, CoreML e muito mais, dando aos desenvolvedores flexibilidade para executar seus modelos em várias plataformas. À medida que cresce a adoção da IA visual, essas integrações simplificam a implantação de sistemas inteligentes criados para funcionar com eficiência em condições reais.

Tem curiosidade sobre IA? Confira nosso repositório no GitHub, participe da nossa comunidade e explore nossas opções de licenciamento para dar início ao seu projeto de IA de visão. Saiba mais sobre inovações como IA no varejo e visão computacional na logística visitando nossas páginas de soluções.