Implante modelos Ultralytics YOLO usando a integração ExecuTorch

Certas aplicações de computer vision, como inspeção de qualidade automatizada, drones autônomos ou sistemas de segurança inteligentes, funcionam melhor quando os modelos Ultralytics YOLO, como Ultralytics YOLO11, executam perto do sensor que captura 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 edge AI, permite que os modelos realizem 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 conseguem menor latência, privacidade de dados aprimorada e maior confiabilidade, mesmo em ambientes com conectividade com a internet limitada ou inexistente.

Por exemplo, uma câmara de fabrico que inspeciona milhares de produtos por minuto, ou um drone a navegar em ambientes complexos, não se podem dar ao luxo dos atrasos associados ao processamento na cloud. Executar o Ultralytics YOLO11 diretamente no dispositivo permite uma inferência instantânea no próprio dispositivo.

Para tornar a execução de modelos Ultralytics YOLO no edge mais fácil e eficiente, a nova ExecuTorch integration suportada pela Ultralytics fornece uma maneira simplificada de exportar e implantar modelos diretamente em dispositivos móveis e embarcados. O ExecuTorch faz parte do ecossistema PyTorch Edge e fornece uma solução ponta a ponta para executar modelos de IA diretamente em hardware móvel e de edge, incluindo telefones, 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!

O 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.

Levando 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 edge especializados. O ExecuTorch também se integra ao pipeline de exportação do PyTorch, fornecendo suporte a recursos avançados, como quantization e manipulação 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 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 (Source)

Uma 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.

Principais 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.

Como 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.

Passo 1: Instale o pacote Python da Ultralytics#

Para começar, precisas de instalar o Ultralytics Python package utilizando o pip, que é um instalador de pacotes. Podes fazê-lo executando “pip install ultralytics” no teu 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 enfrentares algum problema durante a instalação ou ao exportar o teu modelo, a documentação oficial da Ultralytics e o Common Issues guide possuem etapas detalhadas de solução de problemas e práticas recomendadas para te ajudar a começar a funcionar sem problemas.

Passo 2: Exportando o Ultralytics YOLO11#

Após instalar o pacote Ultralytics, podes carregar uma variante do modelo YOLO11 e export ela para o formato ExecuTorch. Por exemplo, podes 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 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")

Passo 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 Ultralytics YOLO11 exportado no formato ExecuTorch.

Benefí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 os modelos Ultralytics YOLO11 exportados para o formato ExecuTorch funcionam cerca de 2 vezes mais rápido do que os seus equivalentes em PyTorch, com uma 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.

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

Recentemente, a Ultralytics foi reconhecida como um PyTorch ExecuTorch success story, destacando o nosso suporte precoce para inferência no dispositivo e contribuições contínuas para o ecossistema PyTorch. Esse reconhecimento reflete um objetivo compartilhado de tornar a IA de alto desempenho mais acessível em plataformas móveis e de edge.

Da nuvem ao edge: Como ExecuTorch e Ultralytics 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 Ultralytics YOLO11 para analisar uma linha de montagem industrial. (Fonte)

Em vez de enviar imagens ou dados de sensores para a cloud para processamento, o que pode introduzir atrasos e depender da conectividade à internet, a integração ExecuTorch permite que os modelos Ultralytics YOLO11 sejam executados diretamente no hardware local. Isto significa que as fábricas podem detetar problemas de qualidade instantaneamente, reduzir o tempo de inatividade e manter a privacidade dos dados, tudo isto operando com recursos computacionais 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 Ultralytics YOLO11 localmente com o ExecuTorch, as cidades podem tomar decisões mais rápidas e baseadas em dados, desde a deteção de engarrafamentos até à identificação de perigos, melhorando a mobilidade e a segurança gerais.
• 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: Os modelos Ultralytics YOLO11 otimizados para edge 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 YOLO11 (Source)

Principais 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.

Tens curiosidade sobre IA? Consulta o nosso GitHub repository, junta-te a our community e explora as nossas licensing options para dar início ao teu projeto de IA de visão. Sabe mais sobre inovações como AI in retail e computer vision in logistics visitando as nossas páginas de soluções.