Este documento explica como treinar um modelo e executar inferência usando um microcontrolador.
O exemplo Hello World
O exemplo Hello World foi desenvolvido para demonstrar os fundamentos absolutos do uso do TensorFlow Lite para microcontroladores. Treinamos e executamos um modelo que replica uma função de seno, ou seja, recebe um único número como entrada e gera como saída o valor do seno do número. Quando implantado no microcontrolador, suas previsões são usadas para piscar os LEDs ou controlar uma animação.
O fluxo de trabalho de ponta a ponta envolve as seguintes etapas:
- Treinar um modelo (em Python): Um arquivo python para treinar, converter e otimizar um modelo para uso no dispositivo.
- Executar inferência (em C++ 17): um teste de unidade de ponta a ponta que executa inferência no modelo usando a biblioteca C++ .
Obtenha um dispositivo compatível
O aplicativo de exemplo que usaremos foi testado nos seguintes dispositivos:
- Arduino Nano 33 BLE Sense (usando Arduino IDE)
- SparkFun Edge (construindo diretamente da fonte)
- Kit STM32F746 Discovery (usando Mbed)
- Adafruit EdgeBadge (usando Arduino IDE)
- Kit Adafruit TensorFlow Lite para Microcontroladores (usando Arduino IDE)
- Adafruit Circuit Playground Bluefruit (usando Arduino IDE)
- Espressif ESP32-DevKitC (usando ESP IDF)
- Espressif ESP-EYE (usando ESP IDF)
Saiba mais sobre as plataformas compatíveis com o TensorFlow Lite para microcontroladores .
Treine um modelo
Use train.py para treinamento de modelo hello world para reconhecimento de sinwave
Execute: bazel build tensorflow/lite/micro/examples/hello_world:train
bazel-bin/tensorflow/lite/micro/examples/hello_world/train --save_tf_model --save_dir=/tmp/model_created/
Executar inferência
Para executar o modelo em seu dispositivo, seguiremos as instruções no README.md
:
As seções a seguir percorrem o teste de unidade de exemplo evaluate_test.cc
, que demonstra como executar a inferência usando o TensorFlow Lite para microcontroladores. Ele carrega o modelo e executa a inferência várias vezes.
1. Inclua os cabeçalhos da biblioteca
Para usar a biblioteca TensorFlow Lite for Microcontrollers, devemos incluir os seguintes arquivos de cabeçalho:
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"
-
micro_mutable_op_resolver.h
fornece as operações usadas pelo interpretador para executar o modelo. -
micro_error_reporter.h
gera informações de depuração. -
micro_interpreter.h
contém código para carregar e executar modelos. -
schema_generated.h
contém o esquema para o formato de arquivo de modelo TensorFlow LiteFlatBuffer
. -
version.h
fornece informações de versão para o esquema do TensorFlow Lite.
2. Inclua o cabeçalho do modelo
O interpretador do TensorFlow Lite para microcontroladores espera que o modelo seja fornecido como uma matriz C++. O modelo é definido nos arquivos model.h
e model.cc
. O cabeçalho é incluído com a seguinte linha:
#include "tensorflow/lite/micro/examples/hello_world/model.h"
3. Inclua o cabeçalho da estrutura de teste de unidade
Para criar um teste de unidade, incluímos a estrutura de teste de unidade do TensorFlow Lite para microcontroladores incluindo a seguinte linha:
#include "tensorflow/lite/micro/testing/micro_test.h"
O teste é definido usando as seguintes macros:
TF_LITE_MICRO_TESTS_BEGIN
TF_LITE_MICRO_TEST(LoadModelAndPerformInference) {
. // add code here
.
}
TF_LITE_MICRO_TESTS_END
Agora discutimos o código incluído na macro acima.
4. Configure o log
Para configurar o registro, um ponteiro tflite::ErrorReporter
é criado usando um ponteiro para uma instância tflite::MicroErrorReporter
:
tflite::MicroErrorReporter micro_error_reporter;
tflite::ErrorReporter* error_reporter = µ_error_reporter;
Essa variável será passada para o interpretador, o que permite gravar logs. Como os microcontroladores costumam ter uma variedade de mecanismos para registro, a implementação de tflite::MicroErrorReporter
foi projetada para ser personalizada para seu dispositivo específico.
5. Carregue um modelo
No código a seguir, o modelo é instanciado usando dados de uma matriz char
, g_model
, que é declarada em model.h
. Em seguida, verificamos o modelo para garantir que sua versão do esquema seja compatível com a versão que estamos usando:
const tflite::Model* model = ::tflite::GetModel(g_model);
if (model->version() != TFLITE_SCHEMA_VERSION) {
TF_LITE_REPORT_ERROR(error_reporter,
"Model provided is schema version %d not equal "
"to supported version %d.\n",
model->version(), TFLITE_SCHEMA_VERSION);
}
6. Instanciar o resolvedor de operações
Uma instância MicroMutableOpResolver
é declarada. Isso será usado pelo interpretador para registrar e acessar as operações que são usadas pelo modelo:
using HelloWorldOpResolver = tflite::MicroMutableOpResolver<1>;
TfLiteStatus RegisterOps(HelloWorldOpResolver& op_resolver) {
TF_LITE_ENSURE_STATUS(op_resolver.AddFullyConnected());
return kTfLiteOk;
O MicroMutableOpResolver
requer um parâmetro de modelo indicando o número de operações que serão registradas. A função RegisterOps
registra as operações com o resolvedor.
HelloWorldOpResolver op_resolver;
TF_LITE_ENSURE_STATUS(RegisterOps(op_resolver));
7. Alocar memória
Precisamos pré-alocar uma certa quantidade de memória para arrays de entrada, saída e intermediários. Isso é fornecido como uma matriz uint8_t
de tamanho tensor_arena_size
:
const int tensor_arena_size = 2 * 1024;
uint8_t tensor_arena[tensor_arena_size];
O tamanho necessário dependerá do modelo que você está usando e pode precisar ser determinado por experimentação.
8. Instancie o interpretador
Criamos uma instância tflite::MicroInterpreter
, passando as variáveis criadas anteriormente:
tflite::MicroInterpreter interpreter(model, resolver, tensor_arena,
tensor_arena_size, error_reporter);
9. Alocar tensores
Dizemos ao interpretador para alocar memória do tensor_arena
para os tensores do modelo:
interpreter.AllocateTensors();
10. Valide a forma de entrada
A instância MicroInterpreter
pode nos fornecer um ponteiro para o tensor de entrada do modelo chamando .input(0)
, onde 0
representa o primeiro (e único) tensor de entrada:
// Obtain a pointer to the model's input tensor
TfLiteTensor* input = interpreter.input(0);
Em seguida, inspecionamos esse tensor para confirmar se sua forma e tipo são os que esperamos:
// Make sure the input has the properties we expect
TF_LITE_MICRO_EXPECT_NE(nullptr, input);
// The property "dims" tells us the tensor's shape. It has one element for
// each dimension. Our input is a 2D tensor containing 1 element, so "dims"
// should have size 2.
TF_LITE_MICRO_EXPECT_EQ(2, input->dims->size);
// The value of each element gives the length of the corresponding tensor.
// We should expect two single element tensors (one is contained within the
// other).
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[0]);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[1]);
// The input is a 32 bit floating point value
TF_LITE_MICRO_EXPECT_EQ(kTfLiteFloat32, input->type);
O valor enum kTfLiteFloat32
é uma referência a um dos tipos de dados do TensorFlow Lite e é definido em common.h
.
11. Forneça um valor de entrada
Para fornecer uma entrada para o modelo, definimos o conteúdo do tensor de entrada, como segue:
input->data.f[0] = 0.;
Nesse caso, inserimos um valor de ponto flutuante representando 0
.
12. Execute o modelo
Para executar o modelo, podemos chamar Invoke()
em nossa instância tflite::MicroInterpreter
:
TfLiteStatus invoke_status = interpreter.Invoke();
if (invoke_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed\n");
}
Podemos verificar o valor de retorno, um TfLiteStatus
, para determinar se a execução foi bem-sucedida. Os possíveis valores de TfLiteStatus
, definidos em common.h
, são kTfLiteOk
e kTfLiteError
.
O código a seguir afirma que o valor é kTfLiteOk
, o que significa que a inferência foi executada com êxito.
TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, invoke_status);
13. Obtenha a saída
O tensor de saída do modelo pode ser obtido chamando output(0)
no tflite::MicroInterpreter
, onde 0
representa o primeiro (e único) tensor de saída.
No exemplo, a saída do modelo é um único valor de ponto flutuante contido em um tensor 2D:
TfLiteTensor* output = interpreter.output(0);
TF_LITE_MICRO_EXPECT_EQ(2, output->dims->size);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[0]);
TF_LITE_MICRO_EXPECT_EQ(1, input->dims->data[1]);
TF_LITE_MICRO_EXPECT_EQ(kTfLiteFloat32, output->type);
Podemos ler o valor diretamente do tensor de saída e afirmar que é o que esperamos:
// Obtain the output value from the tensor
float value = output->data.f[0];
// Check that the output value is within 0.05 of the expected value
TF_LITE_MICRO_EXPECT_NEAR(0., value, 0.05);
14. Execute a inferência novamente
O restante do código executa a inferência várias vezes. Em cada instância, atribuímos um valor ao tensor de entrada, invocamos o interpretador e lemos o resultado do tensor de saída:
input->data.f[0] = 1.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(0.841, value, 0.05);
input->data.f[0] = 3.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(0.141, value, 0.05);
input->data.f[0] = 5.;
interpreter.Invoke();
value = output->data.f[0];
TF_LITE_MICRO_EXPECT_NEAR(-0.959, value, 0.05);