Implante modelos Ultralytics YOLO usando a integração ExecuTorch

Certos aplicativos de visão computacional, como inspeção automatizada de qualidade, drones autônomos ou sistemas inteligentes de segurança, apresentam melhor desempenho quando modelos YOLO da Ultralytics, 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 realizem a inferência diretamente no dispositivo onde os dados são capturados. Ao processar informações localmente, em vez de depender de servidores remotos, os sistemas podem obter menor latência, maior privacidade de dados e maior confiabilidade, mesmo em ambientes com conectividade à internet limitada ou inexistente.

Por exemplo, uma câmera de fabricação que inspeciona milhares de produtos por minuto, ou um drone navegando em ambientes complexos, não pode se dar ao luxo de sofrer os atrasos causados pelo processamento na nuvem. Executar o YOLO11 diretamente no dispositivo permite uma inferência instantânea no próprio aparelho.

Para tornar a execução de modelos YOLO da Ultralytics na borda mais fácil e eficiente, a nova integração com o ExecuTorch, suportada pela Ultralytics, oferece uma maneira simplificada de exportar e implementar modelos diretamente em dispositivos móveis e embarcados. O ExecuTorch faz parte do ecossistema PyTorch Edge e fornece uma solução completa para executar modelos de IA diretamente em hardware móvel e de borda, incluindo celulares, wearables, placas embarcadas e microcontroladores.

Essa integração torna simples levar um modelo YOLO da Ultralytics, como o YOLO11, do treinamento à implementação em dispositivos de borda. Ao combinar as capacidades de visão do YOLO11 com o tempo de execução leve do ExecuTorch e o pipeline de exportação do PyTorch, os usuários podem implementar modelos que rodam de forma eficiente em hardware de borda, preservando a precisão e o desempenho da inferência baseada em PyTorch.

Neste artigo, veremos mais de perto como a integração com o ExecuTorch funciona, por que ela é ideal para aplicações de IA de borda e como você pode começar a implementar modelos YOLO da Ultralytics com o ExecuTorch. Vamos começar!

Link to this sectionO que é o ExecuTorch?#

Normalmente, quando você treina um modelo no PyTorch, ele roda em servidores potentes ou unidades de processamento gráfico (GPUs) na nuvem. No entanto, implementar esse mesmo modelo em um dispositivo móvel ou embarcado, como um smartphone, drone ou microcontrolador, requer uma solução especializada que possa lidar com poder de processamento, memória e conectividade limitados.

É exatamente isso que o ExecuTorch oferece. O ExecuTorch é uma solução completa desenvolvida como parte do ecossistema PyTorch Edge que permite uma inferência eficiente no dispositivo em plataformas móveis, embarcadas e de borda. Ele estende as capacidades do PyTorch para além da nuvem, permitindo que modelos de IA rodem diretamente em dispositivos locais.

Link to this sectionLevando a inferência do PyTorch para a borda#

Em sua essência, o ExecuTorch fornece um tempo de execução C++ leve que permite que modelos PyTorch sejam executados diretamente no dispositivo. O ExecuTorch usa o formato de modelo PyTorch ExecuTorch (.pte), uma exportação otimizada projetada para carregamento mais rápido, menor consumo de memória e maior portabilidade.

Ele suporta o XNNPACK como o backend padrão para inferência eficiente em CPU e estende a compatibilidade a uma ampla gama 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 de borda especializados. 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 formato dinâmico para melhorar o desempenho e a adaptabilidade em diferentes ambientes de implementação.

A quantização reduz o tamanho do modelo e aumenta a velocidade de inferência convertendo valores de alta precisão (como números de ponto flutuante de 32 bits) em valores de menor precisão, enquanto o tratamento de formato dinâmico é usado para permitir que os modelos processem tamanhos de entrada variáveis de forma eficiente. Ambos os recursos são cruciais para executar modelos de IA em dispositivos de borda com recursos limitados.

Fig 1. Uma olhada em como o ExecuTorch funciona (Fonte)

Link to this sectionUma camada unificada para hardware de borda#

Além do seu tempo de execução, o ExecuTorch também atua como uma camada de abstração unificada para múltiplos backends de hardware. Simplificando, ele abstrai detalhes específicos do hardware e gerencia como os modelos interagem com diferentes unidades de processamento, incluindo CPUs, GPUs e NPUs.

Uma vez que um modelo é exportado, o ExecuTorch pode ser configurado para atingir o backend mais adequado para um determinado dispositivo. Desenvolvedores podem implementar modelos eficientemente em diversos hardwares sem escrever código específico para cada dispositivo ou manter fluxos de trabalho de conversão separados.

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

Link to this sectionPrincipais recursos do ExecuTorch#

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

Aqui está um vislumbre de alguns dos seus principais recursos:

• Suporte à quantização: O ExecuTorch suporta a 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 rodar mais rápido e usar menos memória em dispositivos de borda, mantendo quase o mesmo nível de precisão.
• Uso eficiente de memória: Uma das maiores vantagens do ExecuTorch é como ele gerencia a memória. Em vez de depender de alocação de memória dinâmica, que pode introduzir latência e sobrecarga de energia, o ExecuTorch usa planejamento de memória AOT (Ahead-of-Time). Durante a exportação, ele analisa o gráfico do modelo e pré-calcula quanta memória é necessária para cada operação. Isso permite que o tempo de execução execute modelos usando um plano de memória estático, garantindo desempenho previsível e evitando lentidões ou travamentos em dispositivos com RAM ou capacidade de processamento limitadas.
• Metadados de modelo integrados: Ao exportar usando a integração suportada pela Ultralytics, cada modelo inclui um arquivo YAML que contém metadados importantes, como tamanho da imagem de entrada, nomes de classes e parâmetros de configuração. Esse arquivo adicional simplifica a integração do modelo em vários aplicativos e garante um comportamento consistente em diferentes plataformas de borda.

Link to this sectionComo exportar modelos YOLO da Ultralytics para o formato ExecuTorch#

Agora que temos uma compreensão melhor do que o ExecuTorch oferece, vamos percorrer as etapas de como exportar modelos YOLO da Ultralytics para o formato ExecuTorch.

Link to this sectionPasso 1: Instale o pacote Python da Ultralytics#

Para começar, você precisará instalar o pacote Python da Ultralytics usando o pip, que é um instalador de pacotes. Você pode fazer isso executando “pip install ultralytics” no seu terminal ou prompt de comando.

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

Se você enfrentar problemas durante a instalação ou ao exportar seu modelo, a documentação oficial da Ultralytics e o guia de Problemas Comuns possuem etapas detalhadas de solução de problemas e melhores práticas para ajudá-lo a começar sem complicações.

Link to this sectionPasso 2: Exportando o Ultralytics YOLO11#

Após 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 export com o formato definido como “executorch”.

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

Aqui está o código para exportar seu modelo:

from ultralytics import YOLO

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

Link to this sectionPasso 3: Executando inferências após exportar o modelo#

Uma vez exportado, o modelo está pronto para ser implementado em dispositivos de borda e móveis usando o tempo de execução do ExecuTorch. O arquivo de modelo .pte exportado pode ser carregado no seu aplicativo para executar inferência em tempo real e no próprio dispositivo, sem a necessidade de uma conexão com a nuvem.

Por exemplo, o snippet 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 em novos dados. Aqui, o modelo é testado em uma imagem de um ônibus tirada de uma URL pública.

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

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

Fig 2. Detectando objetos usando um modelo YOLO11 exportado no formato ExecuTorch.

Link to this sectionBenefícios de usar a integração com o ExecuTorch#

Ao explorar as diferentes opções de exportação suportadas pela Ultralytics, você pode se perguntar o que torna a integração com o ExecuTorch única. A principal diferença é como ela combina desempenho, simplicidade e flexibilidade, facilitando a implementação de modelos de IA poderosos diretamente em dispositivos móveis e de borda.

Aqui está uma olhada em algumas das principais vantagens de usar a integração com o ExecuTorch:

• Opções de implementação flexíveis: Modelos ExecuTorch podem ser implementados em aplicativos móveis, sistemas embarcados, dispositivos IoT (Internet das Coisas) e hardware de IA de borda especializado. Essa flexibilidade permite que os desenvolvedores criem soluções de IA escaláveis que funcionam de forma consistente em diversas plataformas e ambientes.
• Desempenho comprovado por benchmarks: Testes em dispositivos como o Raspberry Pi 5 mostram que modelos YOLO11 exportados para o formato ExecuTorch rodam aproximadamente 2x mais rápido do que suas contrapartes PyTorch, com precisão quase idêntica.
• APIs de integração flexíveis: O ExecuTorch fornece APIs C++, Kotlin e Objective-C para iOS, Android e Linux embarcado, permitindo que os desenvolvedores integrem modelos YOLO diretamente em aplicativos nativos.
• Suporte a aceleração de hardware: O ExecuTorch suporta múltiplos backends de aceleração de 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 aumentos substanciais de velocidade em relação à inferência apenas por CPU.

Link to this sectionAplicações no mundo real do YOLO11 e da exportação para ExecuTorch#

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

Link to this sectionDa nuvem à borda: Como o ExecuTorch e o YOLO11 dão vida à IA de visão#

Na prática, isso se traduz em soluções de IA de visão do mundo real rodando de forma eficiente em tudo, desde smartphones a sistemas embarcados. Por exemplo, na fabricação, dispositivos de borda desempenham um papel crucial no monitoramento de linhas de produção e na detecção de defeitos em tempo real.

Fig 3. Um exemplo de uso do 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 de conexão com a internet, a integração com o ExecuTorch permite que modelos YOLO11 rodem diretamente no hardware local. Isso significa que as fábricas podem detectar problemas de qualidade instantaneamente, reduzir o tempo de inatividade e manter a privacidade dos dados, tudo isso operando com recursos de computação limitados.

Aqui estão alguns outros exemplos de como a integração com o ExecuTorch e os modelos YOLO da Ultralytics podem ser aplicados:

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

Fig 4. Detectando e contando carros no tráfego usando o YOLO11 (Fonte)

Link to this sectionPrincipais pontos#

Exportar modelos YOLO da Ultralytics para o formato ExecuTorch torna fácil implementar modelos de visão computacional em muitos dispositivos, incluindo smartphones, tablets e sistemas embarcados como o Raspberry Pi. Isso significa que é possível executar uma inferência otimizada no próprio dispositivo, sem depender de conectividade com a nuvem, melhorando a velocidade, a privacidade e a confiabilidade.

Além do ExecuTorch, a Ultralytics suporta uma ampla gama de integrações, incluindo TensorRT, OpenVINO, CoreML e outras, dando aos desenvolvedores a flexibilidade de rodar seus modelos em várias plataformas. À medida que a adoção da IA de visão cresce, essas integrações simplificam a implementação de sistemas inteligentes construídos para ter um desempenho eficiente em condições reais.

Curioso sobre IA? Confira nosso repositório no GitHub, junte-se à nossa comunidade e explore nossas opções de licenciamento para dar o pontapé inicial no 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.