Como executar um modelo de aprendizagem de máquina "Olá mundo" em microcontroladores STM32

O aprendizado de máquinas (ML) tem sido a mania em aplicações de servidor e móveis por anos, mas agora migrou e se tornou crítico em dispositivos de borda. Dado que os dispositivos de borda precisam ser eficientes em termos energéticos, os desenvolvedores precisam aprender e entender como implantar modelos ML em sistemas baseados em microcontroladores. Os modelos ML rodando em um microcontrolador são frequentemente citados como tinyML. Infelizmente, implantar um modelo para um microcontrolador não é uma tarefa trivial. Ainda assim, está ficando mais fácil, e os desenvolvedores sem nenhum treinamento especializado descobrirão que podem fazê-lo de forma oportuna.

Este artigo explora como os desenvolvedores de embarcados podem começar a usar os microcontroladores STM32 da STMicroelectronics com ML. Para fazer isso, é mostrado como criar uma aplicação "Olá mundo" convertendo um modelo TensorFlow Lite para Microcontroladores para uso em STM32CubeIDE usando X-CUBE-AI.

Introdução aos casos de uso do tinyML

TinyML é um campo em crescimento que traz o poder do ML para dispositivos com limitações de recursos e energia, como microcontroladores, geralmente usando redes neurais profundas. Estes dispositivos microcontroladores podem então executar o modelo ML e realizar um trabalho valioso na borda. Há vários casos de uso em que o tinyML é atualmente bastante interessante.

O primeiro caso de uso, que é visto em muitos dispositivos móveis e equipamentos de automação doméstica, é a detecção de palavras-chave. A detecção de palavras-chave permite que o dispositivo embarcado use um microfone para capturar a fala e detectar palavras-chave pré-treinadas. O modelo tinyML utiliza uma entrada de série temporal que representa a fala e a converte em características da fala, geralmente um espectrograma. O espectrograma contém informações de frequência ao longo do tempo. O espectrograma é então alimentado em uma rede neural treinada para detectar palavras específicas, e o resultado é uma probabilidade de que uma palavra específica seja detectada. A Figura 1 mostra um exemplo de como é este processo.

Figura 1: Detecção de palavras-chave é um caso de uso interessante para o tinyML. A fala de entrada é convertida em um espectrograma e depois alimentado em uma rede neural treinada para determinar se uma palavra pré-treinada está presente. (Fonte da imagem: Arm®)

O próximo caso de uso para o tinyML, no qual muitos desenvolvedores de embarcados estão interessados, é o reconhecimento de imagem. O microcontrolador captura imagens de uma câmera, que são então alimentadas em um modelo pré-treinado. O modelo pode discernir o que está na imagem. Por exemplo, pode-se determinar se existe um gato, um cão, um peixe, e assim por diante. Um grande exemplo de como o reconhecimento de imagem é usado na borda está nas campainhas de vídeo. A campainha de vídeo pode muitas vezes detectar se um humano está presente na porta ou se um pacote foi deixado.

Um último caso de uso com grande popularidade é o uso do tinyML para manutenção preditiva. A manutenção preditiva usa ML para prever os estados do equipamento com base na detecção de anormalidades, algoritmos de classificação e modelos preditivos. Mais uma vez, muitas aplicações estão disponíveis, desde sistemas HVAC até equipamentos de chão de fábrica.

Embora os três casos de uso acima sejam atualmente populares para o tinyML, há sem dúvida muitos casos de uso potencial que os desenvolvedores podem encontrar. Aqui está uma lista rápida:

• Classificação por gestos
• Detecção de anomalias
• Leitor de medidor analógico
• Orientação e controle (GNC)
• Detecção de embalagens

Não importa o caso de uso, a melhor maneira de começar a se familiarizar com o tinyML é com um aplicativo "Olá mundo", que ajuda os desenvolvedores a aprender e entender o processo básico que eles seguirão para ter um sistema mínimo em funcionamento. Há cinco passos necessários para executar um modelo tinyML em um microcontrolador STM32:

1. Capturar dados
2. Rotular dados
3. Treinar a rede neural
4. Converter o modelo
5. Executar o modelo no microcontrolador

Capturar, rotular e treinar um modelo "Olá mundo"

Os desenvolvedores geralmente têm muitas opções disponíveis para a forma como capturam e rotulam os dados necessários para treinar seu modelo. Em primeiro lugar, existem muitos bancos de dados de treinamento on-line. Os desenvolvedores podem pesquisar os dados que alguém coletou e rotulou. Por exemplo, para a detecção básica de imagens, existe o CIFAR-10 ou ImageNet. Para treinar um modelo a detectar sorrisos em fotos, há uma coleção de imagens para isso também. Os repositórios de dados on-line são claramente um ótimo lugar para se começar.

Se os dados necessários ainda não foram disponibilizados publicamente na Internet, então outra opção é que os desenvolvedores possam gerar seus próprios dados. O Matlab ou alguma outra ferramenta pode ser usado para gerar os conjuntos de dados. Se a geração automática de dados não for uma opção, ela pode ser feita manualmente. Finalmente, se tudo isso parecer muito demorado, há alguns conjuntos de dados disponíveis para compra, também na Internet. A coleta de dados é frequentemente a opção mais excitante e interessante, mas é também a mais trabalhosa.

O exemplo do "Olá mundo" que está sendo explorado aqui mostra como treinar um modelo para gerar uma onda senoidal e implantá-la em um STM32. O exemplo foi apresentado por Pete Warden e Daniel Situnayake como parte de seu trabalho no Google no TensorFlow Lite para Microcontroladores. Isto facilita o trabalho porque eles elaboraram um tutorial simples e público sobre como capturar, rotular e treinar o modelo. Ele pode ser encontrado no Github aqui; uma vez lá, os desenvolvedores devem clicar no botão "Executar no Google Colab". Google Colab, abreviação para "Google Collaboratory", permite aos desenvolvedores escrever e executar Python em seu navegador com configuração zero e fornece acesso gratuito às GPUs do Google.

A saída do exemplo de treinamento incluirá dois arquivos de modelos diferentes; um modelo TensorFlow model.tflite que é quantificado para microcontroladores e um modelo model_no_quant.tflite que não é quantificado. A quantização indica como as ativações e a polarização do modelo são armazenadas numericamente. A versão quantizada produz um modelo menor que é mais adequado para um microcontrolador. Para esses leitores curiosos, os resultados do modelo treinado versus os resultados reais da onda senoidal podem ser vistos na Figura 2. A saída do modelo está em vermelho. A saída de onda senoidal não é perfeita, mas funciona bem o suficiente para um programa "Olá Mundo".

Figura 2: Uma comparação entre as previsões do modelo TensorFlow para uma onda senoidal versus os valores reais. (Fonte da imagem: Beningo Embedded Group)

Selecionando uma placa de desenvolvimento

Antes de analisar como converter o modelo TensorFlow para funcionar em um microcontrolador, um microcontrolador precisa ser selecionado para ser implantado no modelo. Este artigo se concentrará nos microcontroladores STM32 porque a STMicroelectronics tem muitas ferramentas tinyML/ML que funcionam bem para converter e executar modelos. Além disso, a STMicroelectronics possui uma grande variedade de peças compatíveis com suas ferramentas ML (Figura 3).

Figura 3: São mostrados os microcontroladores e a unidade microprocessadora (MPU) atualmente suportados pelo ecossistema STMicroelectronics AI. (Fonte da imagem: STMicroelectronics)

Se uma dessas placas estiver largada num canto da oficina, é perfeita para colocar em funcionamento a aplicação "Olá mundo". Entretanto, para aqueles interessados em ir além deste exemplo e entrar no controle por gestos ou na detecção de palavras-chave, opte pelo nó Iot Discovery STM32 B-L4S5I-IOT01A (Figura 4).

Esta placa tem um processador Arm Cortex®-M4 baseado na série STM32L4+. O processador tem 2 megabytes (Mbytes) de memória flash e 640 quilobytes (Kbytes) de RAM, proporcionando muito espaço para modelos tinyML. O módulo é adaptável para casos de uso experimental do tinyML porque também possui o microfone de sistemas microeletromecânicos (MEMS) MP34DT01 da STMicroelectronics que pode ser usado para o desenvolvimento de aplicações de detecção de palavras-chave. Além disso, o acelerômetro de três eixos LIS3MDLTR na placa, também da STMicroelectronics, pode ser usado para a detecção de gestos baseados em tinyML.

Figura 4: O STM32 B-L4S5I-IOT01A nó IoT Discovery é uma plataforma de experimentação adaptável para o tinyML devido a seu processador Arm Cortex-M4, microfone MEMS e acelerômetro de três eixos na placa. (Fonte da imagem: STMicroelectronics)

Conversão e execução do modelo TensorFlow Lite utilizando o STM32Cube.AI

Armados com uma placa de desenvolvimento que pode ser usada para executar o modelo tinyML, os desenvolvedores podem agora começar a converter o modelo TensorFlow Lite em algo que possa rodar no microcontrolador. O modelo TensorFlow Lite pode funcionar diretamente no microcontrolador, mas precisa de um ambiente de tempo de execução para processá-lo.

Quando o modelo é executado, uma série de funções precisa ser realizada. Estas funções começam com a coleta dos dados do sensor, depois a filtragem, a extração das características necessárias e a alimentação do modelo. O modelo retornará um resultado que pode então ser filtrado e, em seguida, normalmente, são tomadas algumas ações. A Figura 5 fornece uma visão geral de como este processo se apresenta.

Figura 5: Como os dados fluem dos sensores para o tempo de execução e depois para a saída em uma aplicação tinyML. (Fonte da imagem: Beningo Embedded Group)

O plug-in X-CUBE-AI para STM32CubeMx fornece o ambiente de tempo de execução para interpretar o modelo TensorFlow Lite e oferece tempos de execução alternativos e ferramentas de conversão que os desenvolvedores podem aproveitar. O plug-in X-CUBE-AI não é habilitado por padrão em um projeto. Entretanto, após criar um novo projeto e inicializar a placa, em Pacotes de Software-> Selecionar Componentes, há uma opção para habilitar o tempo de execução da AI. Há várias opções aqui; certifique-se de que o modelo de aplicação seja usado para este exemplo, como mostrado na Figura 6.

Figura 6: O plug-in X-CUBE-AI precisa ser habilitado usando o modelo de aplicação para este exemplo. (Fonte da imagem: Beningo Embedded Group)

Uma vez habilitado o X-CUBE-AI, uma categoria STMicroelectronics X-CUBE-AI aparecerá na cadeia de ferramentas. Clicando na categoria, o desenvolvedor poderá selecionar o arquivo de modelo que criou e definir os parâmetros do modelo, como mostrado na Figura 7. Um botão de análise também analisará o modelo e fornecerá aos desenvolvedores informações sobre RAM, ROM e ciclo de execução. É altamente recomendável que os desenvolvedores comparem as opções dos modelos Keras e TFLite. No exemplo do modelo de onda senoidal, que é pequeno, não haverá uma grande diferença, mas é perceptível. O projeto pode então ser gerado clicando em "Gerar código".

Figura 7: O botão de análise fornecerá aos desenvolvedores informações sobre RAM, ROM e ciclo de execução. (Fonte da imagem: Beningo Embedded Group)

O gerador de código irá inicializar o projeto e compilar no ambiente do tempo de execução para o modelo tinyML. Entretanto, por padrão, nada está alimentando o modelo. Os desenvolvedores precisam adicionar código para fornecer os valores de entrada do modelo — valores de x — que o modelo então interpretará e utilizará para gerar os valores senoidais de y. Algumas peças de código precisam ser adicionadas às funções de acquire_and_process_data e post_process, como mostrado na Figura 8.

Figura 8: O código mostrado conectará os valores falsos do sensor de entrada ao modelo de onda senoidal. (Fonte da imagem: Beningo Embedded Group)

Neste ponto, o exemplo está agora pronto para ser executado. Nota: adicionar algumas declarações printf para obter a saída do modelo para verificação rápida. Uma rápida compilação e implantação resulta na execução do modelo tinyML "Olá mundo". Forçar a saída do modelo para um ciclo completo resulta na onda senoidal mostrada na Figura 9. Não é perfeito, mas é excelente para uma primeira aplicação tinyML. A partir daqui, os desenvolvedores poderiam amarrar a saída a um modulador de largura de pulso (PWM) e gerar a onda senoidal.

Figura 9: A saída do modelo de onda senoidal "Olá mundo" quando em funcionamento no STM32. (Fonte da imagem: Beningo Embedded Group)

Dicas e truques para ML em sistemas embarcados

Os desenvolvedores que desejam começar com o ML em sistemas baseados em microcontroladores terão muito que fazer em sua placa para colocar em funcionamento sua primeira aplicação minúscula tinyML. No entanto, existem várias "dicas e truques" a serem levados em conta que podem simplificar e acelerar seu desenvolvimento:

• Consulte o exemplo "Olá mundo" da TensorFlow Lite para microcontroladores, incluindo o arquivo do Google Colab. Leve algum tempo para ajustar os parâmetros e entender como eles afetam o modelo treinado.
• Use modelos quantizados para aplicações de microcontroladores. O modelo quantizado é comprimido para trabalhar com uint8_t em vez de números de ponto flutuante de 32 bits. Como resultado, o modelo será menor e de execução mais rápida.
• Explore os exemplos adicionais no repositório TensorFlow Lite para Microcontroladores. Outros exemplos incluem a detecção de gestos e a detecção de palavras-chave.
• Pegue o exemplo do "Olá mundo" conectando a saída do modelo a um PWM e um filtro passa-baixo para ver a onda senoidal resultante. Experimente o tempo de execução para aumentar e diminuir a frequência da onda sinusoidal.
• Selecione uma placa de desenvolvimento que inclua sensores "extras" que permitirão que uma ampla gama de aplicações ML seja experimentada.
• Por mais divertido que a coleta de dados possa ser, é geralmente mais fácil adquirir ou usar um banco de dados de código aberto para treinar o modelo.

Os desenvolvedores que seguirem estas "dicas e truques" pouparão bastante tempo e sofrimento ao garantir sua aplicação.

Conclusão

O ML chegou à borda da rede, e os sistemas baseados em microcontroladores com recursos limitados são um alvo principal. As últimas ferramentas permitem que os modelos ML sejam convertidos e otimizados para funcionar em sistemas de tempo real. Como mostrado, colocar um modelo em funcionamento em uma placa de desenvolvimento STM32 é relativamente fácil, apesar das complexidades envolvidas. Enquanto a discussão examinou um modelo simples que gera uma onda senoidal, modelos muito mais complexos como a detecção de gestos e a detecção de palavras-chave são possíveis.