Implementa modelos YOLO da Ultralytics com a integração do ExecuTorch

Determinadas aplicações de visão computacional, como a inspeção de qualidade automatizada, 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. Ou seja, estes modelos precisam de processar os dados diretamente no local onde são gerados, em câmaras, drones ou sistemas incorporados, em vez de os enviar para a nuvem.

Esta abordagem, conhecida como IA de borda, permite que os modelos executem inferências diretamente no dispositivo onde os dados são capturados. Ao processar as informações localmente, em vez de depender de servidores remotos, os sistemas conseguem obter menor latência, maior privacidade dos dados e maior fiabilidade, mesmo em ambientes com conectividade à Internet limitada ou inexistente.

Por exemplo, uma câmara industrial que inspeciona milhares de produtos por minuto ou um drone que navega por ambientes complexos não pode suportar os atrasos associados ao processamento na nuvem. Executar o Ultralytics YOLO11 diretamente no dispositivo permite realizar inferências instantâneas no dispositivo.

Para tornar a execução de modelos Ultralytics YOLO na borda mais fácil e eficiente, a nova integração ExecuTorch, suportada pela Ultralytics, oferece uma forma simplificada de exportar e implementar modelos diretamente em dispositivos móveis e incorporados. 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 telemóveis, dispositivos vestíveis, placas incorporadas e microcontroladores.

Esta integração facilita a passagem de um modelo Ultralytics YOLO, como o YOLO11, do treino para a implementação em dispositivos de borda. Ao combinar as capacidades de visão do YOLO11 com o runtime leve do ExecuTorch e o pipeline de exportação do PyTorch, os utilizadores podem implementar modelos que funcionam eficientemente em hardware de borda, preservando a precisão e o desempenho das inferências baseadas em PyTorch.

Neste artigo, vamos analisar mais detalhadamente como funciona a integração ExecuTorch, por que motivo é uma excelente opção para aplicações de IA de borda e como podes começar a implementar modelos Ultralytics YOLO com o ExecuTorch. Vamos começar!

O que é o ExecuTorch?#

Normalmente, quando treinas um modelo em PyTorch, ele é executado em servidores potentes ou em Unidades de processamento gráfico (GPUs) na nuvem. No entanto, implementar esse mesmo modelo num dispositivo móvel ou incorporado, como um smartphone, drone ou microcontrolador, requer uma solução especializada capaz de lidar com limitações de capacidade computacional, memória e conectividade.

É exatamente isso que o ExecuTorch oferece. O ExecuTorch é uma solução completa desenvolvida como parte do ecossistema PyTorch Edge, que permite realizar inferências eficientes no dispositivo em plataformas móveis, incorporadas e de borda. Estende as capacidades do PyTorch para além da nuvem, permitindo que os modelos de IA sejam executados diretamente em dispositivos locais.

Levar as inferências do PyTorch para a borda#

No seu núcleo, o ExecuTorch fornece um runtime leve em C++ que permite executar modelos PyTorch diretamente no dispositivo. O ExecuTorch utiliza o formato de modelo PyTorch ExecuTorch (.pte), uma exportação otimizada concebida para carregamentos mais rápidos, menor utilização de memória e maior portabilidade.

Suporta XNNPACK como backend predefinido para inferências eficientes na Unidade central de processamento (CPU) e amplia a compatibilidade a uma vasta gama de backends de hardware, incluindo CoreML, Metal, Vulkan, Qualcomm, MediaTek, Arm EthosU, OpenVINO, entre outros.

Estes backends permitem uma aceleração otimizada em dispositivos móveis, incorporados e especializados de borda. O ExecuTorch também se integra no pipeline de exportação do PyTorch, fornecendo suporte para funcionalidades avançadas, como a quantização e o tratamento de formas dinâmicas, 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 ao converter valores de alta precisão, como floats de 32 bits, em valores de menor precisão, enquanto o tratamento de formas dinâmicas permite que os modelos processem eficientemente tamanhos de entrada variáveis. Ambas as funcionalidades são fundamentais para executar modelos de IA em dispositivos de borda com recursos limitados.

Fig. 1. Uma visão geral do funcionamento do ExecuTorch (Fonte)

Uma camada unificada para hardware de borda#

Além do seu runtime, o ExecuTorch também funciona como uma camada de abstração unificada para vários backends de hardware. Em termos simples, abstrai os detalhes específicos do hardware e gere a forma como os modelos interagem com diferentes unidades de processamento, incluindo CPUs, GPUs e Unidades de processamento neural (NPUs).

Depois de exportado um modelo, o ExecuTorch pode ser configurado para utilizar o backend mais adequado para um determinado dispositivo. Os programadores podem implementar modelos eficientemente em hardware diversificado sem escrever código personalizado específico para cada dispositivo nem manter fluxos de conversão separados.

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

Principais funcionalidades do ExecuTorch#

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

Eis uma visão geral de algumas das suas principais funcionalidades:

• Suporte para 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. Isto ajuda os modelos a funcionar mais rapidamente e a utilizar menos memória em dispositivos de borda, mantendo praticamente o mesmo nível de precisão.
• Utilização eficiente da memória: Uma das maiores vantagens do ExecuTorch é a forma como gere a memória. Em vez de depender da alocação dinâmica de memória, que pode introduzir latência e consumo adicional de energia, o ExecuTorch utiliza o planeamento de memória Ahead-of-Time (AOT). Durante a exportação, analisa o grafo do modelo e calcula antecipadamente a quantidade de memória necessária para cada operação. Isto permite ao runtime executar modelos utilizando um plano de memória estático, garantindo um desempenho previsível e evitando lentidões ou falhas em dispositivos com RAM ou capacidade de processamento limitadas.
• Metadados de modelo integrados: Ao exportar utilizando a integração suportada pela Ultralytics, cada modelo inclui um ficheiro YAML com metadados importantes, como o tamanho da imagem de entrada, os nomes das classes e os parâmetros de configuração. Este ficheiro adicional simplifica a integração do modelo em várias aplicações e garante um comportamento consistente em diferentes plataformas de borda.

Como exportar modelos Ultralytics YOLO para o formato ExecuTorch#

Agora que compreendemos melhor o que o ExecuTorch oferece, vamos explicar passo a passo como exportar modelos Ultralytics YOLO para o formato ExecuTorch.

Passo 1: Instalar o pacote Python da Ultralytics#

Para começar, tens de instalar o pacote Python da Ultralytics utilizando o pip, que é um instalador de pacotes. Podes fazê-lo executando “pip install ultralytics” no teu terminal ou na linha de comandos.

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

Se encontrares problemas durante a instalação ou ao exportar o teu modelo, a documentação oficial da Ultralytics e o guia de problemas comuns incluem passos detalhados de resolução de problemas e boas práticas para te ajudarem a começar sem dificuldades.

Passo 2: Exportar o Ultralytics YOLO11#

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

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

Eis o código para exportar o teu modelo:

from ultralytics import YOLO

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

Passo 3: Executar inferências depois de exportar o modelo#

Depois de exportado, o modelo está pronto para ser implementado em dispositivos de borda e móveis utilizando o runtime do ExecuTorch. O ficheiro de modelo .pte exportado pode ser carregado na tua aplicação para executar inferências em tempo real no dispositivo, sem necessidade de uma ligação à nuvem.

Por exemplo, o fragmento de código abaixo mostra como carregar o modelo exportado e executar uma inferência. Inferência significa simplesmente utilizar um modelo treinado para fazer previsões sobre novos dados. Neste caso, o modelo é testado numa imagem de um autocarro obtida a partir de um URL público.

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

Depois de executares o código, encontrarás a imagem de saída com os objetos detetados guardada na pasta “runs/detect/predict”.

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

Vantagens de utilizar a integração ExecuTorch#

Ao explorares as diferentes opções de exportação suportadas pela Ultralytics, podes perguntar-te o que torna a integração ExecuTorch única. A principal diferença está na forma como combina desempenho, simplicidade e flexibilidade, facilitando a implementação de modelos de IA avançados diretamente em dispositivos móveis e de borda.

Eis algumas das principais vantagens de utilizar a integração ExecuTorch:

• Opções de implementação flexíveis: Os modelos ExecuTorch podem ser implementados em aplicações móveis, sistemas incorporados, dispositivos IoT (Internet das Coisas) e hardware especializado de IA de borda. Esta flexibilidade permite aos programadores criar soluções de IA escaláveis que têm um 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 executados aproximadamente 2 vezes mais rapidamente do que os seus equivalentes PyTorch, com uma precisão praticamente idêntica.
• APIs de integração flexíveis: O ExecuTorch fornece APIs C++, Kotlin e Objective-C para iOS, Android e Linux incorporado, permitindo aos programadores integrar modelos YOLO diretamente em aplicações nativas.
• Suporte para aceleração de hardware: O ExecuTorch suporta vários 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 fabricantes. Também pode utilizar aceleradores dedicados, como NPUs e DSPs, para obter ganhos de velocidade significativos em comparação com inferências apenas na CPU.

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

Recentemente, a Ultralytics foi reconhecida numa história de sucesso do PyTorch ExecuTorch, destacando o nosso suporte inicial para inferências no dispositivo e as contribuições contínuas para o ecossistema PyTorch. Este 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, isto traduz-se em soluções de IA de visão do mundo real que funcionam eficientemente desde smartphones até sistemas incorporados. Por exemplo, na indústria transformadora, os dispositivos de borda desempenham um papel fundamental na monitorização das linhas de produção e na deteção de defeitos em tempo real.

Fig. 3. Exemplo de utilização 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 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, operando simultaneamente com recursos computacionais limitados.

Eis alguns outros exemplos de aplicação da integração ExecuTorch e dos modelos Ultralytics YOLO:

• Cidades inteligentes: Ao executar localmente modelos Ultralytics YOLO11 com o ExecuTorch, as cidades podem tomar decisões mais rápidas e baseadas em dados, desde detetar congestionamentos de trânsito até identificar perigos, melhorando a mobilidade e a segurança em geral.
• Retalho e armazenamento: Com inferências no dispositivo, os retalhistas podem automatizar a monitorização de prateleiras, acompanhar o inventário e inspecionar pacotes de forma rápida e segura, sem depender de ligações à nuvem.
• Robótica e drones: Os modelos Ultralytics YOLO11 otimizados para a 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. Deteção e contagem de carros no trânsito utilizando o YOLO11 (Fonte)

Principais conclusões#

Exportar modelos Ultralytics YOLO para o formato ExecuTorch facilita a implementação de modelos de visão computacional em muitos dispositivos, incluindo smartphones, tablets e sistemas incorporados, como o Raspberry Pi. Isto permite executar inferências otimizadas no dispositivo sem depender da conectividade à nuvem, melhorando a velocidade, a privacidade e a fiabilidade.

Além do ExecuTorch, a Ultralytics suporta uma vasta gama de integrações, incluindo TensorRT, OpenVINO, CoreML, entre outras, dando aos programadores a flexibilidade de executar os seus modelos em várias plataformas. À medida que a adoção da IA de visão cresce, estas integrações simplificam a implementação de sistemas inteligentes concebidos para funcionar eficientemente em condições reais.

Interessado em IA? Consulta o nosso repositório no GitHub, junta-te à nossa comunidade e explora as nossas opções de licenciamento para iniciares o teu projeto de IA de visão. Sabe mais sobre inovações como IA no retalho e visão computacional na logística visitando as nossas páginas de soluções.