Os microcontroladores têm RAM e armazenamento limitados, o que restringe os tamanhos dos modelos de machine learning. Além disso, o LiteRT para microcontroladores atualmente oferece suporte a um subconjunto limitado de operações, então nem todas as arquiteturas de modelo são possíveis.
Este documento explica o processo de conversão de um modelo do TensorFlow para execução em microcontroladores. Ele também descreve as operações compatíveis e dá algumas orientações sobre como projetar e treinar um modelo para caber em uma memória limitada.
Para um exemplo completo e executável de como criar e converter um modelo, consulte o exemplo Hello World.
Conversão de modelos
Para converter um modelo treinado do TensorFlow para execução em microcontroladores, use
a API Python do conversor LiteRT. Isso vai
converter o modelo em um FlatBuffer,
reduzindo o tamanho do modelo e modificando-o para usar operações do LiteRT.
Para obter o menor tamanho de modelo possível, considere usar a quantização pós-treinamento.
Converter em uma matriz C
Muitas plataformas de microcontroladores não têm suporte nativo para sistemas de arquivos. A maneira mais fácil de usar um modelo do seu programa é incluí-lo como uma matriz C e compilá-lo no programa.
O comando Unix a seguir vai gerar um arquivo de origem em C que contém o
modelo LiteRT como uma matriz char:
xxd -i converted_model.tflite > model_data.cc
O resultado será semelhante ao seguinte:
unsigned char converted_model_tflite[] = {
0x18, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x00, 0x00, 0x0e, 0x00,
// <Lines omitted>
};
unsigned int converted_model_tflite_len = 18200;
Depois de gerar o arquivo, você pode incluí-lo no seu programa. É
importante mudar a declaração de matriz para const para melhorar a eficiência da memória
em plataformas incorporadas.
Para um exemplo de como incluir e usar um modelo no seu programa, consulte
hello_world_test.cc
no exemplo Hello World.
Arquitetura e treinamento do modelo
Ao projetar um modelo para uso em microcontroladores, é importante considerar o tamanho do modelo, a carga de trabalho e as operações usadas.
Tamanho do modelo
Um modelo precisa ser pequeno o suficiente para caber na memória do dispositivo de destino junto com o restante do programa, tanto como um binário quanto em tempo de execução.
Para criar um modelo menor, use menos camadas e camadas menores na sua arquitetura. No entanto, modelos pequenos têm mais chances de sofrer de underfitting. Isso significa que, para muitos problemas, faz sentido tentar usar o maior modelo que cabe na memória. No entanto, o uso de modelos maiores também vai aumentar a carga de trabalho do processador.
Carga de trabalho
O tamanho e a complexidade do modelo têm um impacto na carga de trabalho. Modelos grandes e complexos podem resultar em um ciclo de trabalho mais alto, o que significa que o processador do dispositivo passa mais tempo trabalhando e menos tempo ocioso. Isso vai aumentar o consumo de energia e a produção de calor, o que pode ser um problema dependendo do seu aplicativo.
Suporte a operações
No momento, o LiteRT para microcontroladores oferece suporte a um subconjunto limitado de operações do TensorFlow, o que afeta as arquiteturas de modelo que podem ser executadas. Estamos trabalhando para expandir o suporte a operações, tanto em termos de implementações de referência quanto de otimizações para arquiteturas específicas.
As operações compatíveis podem ser vistas no arquivo
micro_mutable_ops_resolver.h