O Dia da Comunidade de ML é dia 9 de novembro! Junte-nos para atualização de TensorFlow, JAX, e mais Saiba mais

Comece a usar microcontroladores

Este documento explica como treinar um modelo e executar inferência usando um microcontrolador.

O exemplo Hello World

O Olá Mundo exemplo é projetado para demonstrar os princípios absolutos de usar TensorFlow Lite para microcontroladores. Nós treinamos e executar um modelo que reproduz uma função seno, ou seja, é preciso um único número como sua entrada e saídas do número sine valor. Quando implantado no microcontrolador, suas previsões são usadas para piscar LEDs ou controlar uma animação.

O fluxo de trabalho de ponta a ponta envolve as seguintes etapas:

  1. Treinar um modelo (em Python): Um caderno jupyter de trem, converter e otimizar um modelo para uso no dispositivo.
  2. Inferência correr (em C ++ 11): Um teste de unidade end-to-end que corre inferência sobre o modelo usando a biblioteca C ++ .

Obtenha um dispositivo compatível

O aplicativo de exemplo que usaremos foi testado nos seguintes dispositivos:

Saiba mais sobre as plataformas suportadas em TensorFlow Lite para microcontroladores .

Treine uma modelo

Use Google Colaboratory para treinar o seu próprio modelo . Para mais detalhes, consulte o README.md :

Hello World Training README.md

Executar inferência

Para executar o modelo do seu dispositivo, vamos percorrer as instruções no README.md :

Hello World README.md

As seções a seguir a pé através do exemplo hello_world_test.cc teste, unidade que demonstra como executar inferência usando 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 para Microcontroladores, devemos incluir os seguintes arquivos de cabeçalho:

#include "tensorflow/lite/micro/all_ops_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"

2. Inclua o cabeçalho do modelo

O interpretador TensorFlow Lite para Microcontroladores espera que o modelo seja fornecido como uma matriz C ++. O modelo é definido no model.h e model.cc arquivos. O cabeçalho está incluído na 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 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 discutiremos o código incluído na macro acima.

4. Configure o registro

Para configurar o log, um tflite::ErrorReporter ponteiro é criado usando um ponteiro para uma tflite::MicroErrorReporter exemplo:

tflite::MicroErrorReporter micro_error_reporter;
tflite::ErrorReporter* error_reporter = &micro_error_reporter;

Essa variável será passada para o interpretador, que permite gravar logs. Desde microcontroladores muitas vezes têm uma variedade de mecanismos para o registo, a implementação de tflite::MicroErrorReporter é projetado para ser personalizado para seu dispositivo específico.

5. Carregue um modelo

No seguinte código, o modelo é instanciado usando dados a partir de um char de matriz, g_model , que é declarada na 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. Instancie o resolvedor de operações

Um AllOpsResolver instância é declarada. Isso será usado pelo intérprete para acessar as operações que são usadas pelo modelo:

tflite::AllOpsResolver resolver;

Os AllOpsResolver carrega todos as operações disponíveis no TensorFlow Lite para microcontroladores, que usa muita memória. Como um determinado modelo usará apenas um subconjunto dessas operações, é recomendável que os aplicativos do mundo real carreguem apenas as operações necessárias.

Isso é feito usando uma classe diferente, MicroMutableOpResolver . Você pode ver como usá-lo em de exemplo discurso Micro micro_speech_test.cc .

7. Alocar memória

Precisamos pré-alocar uma certa quantidade de memória para entrada, saída e matrizes intermediárias. Este é fornecido como um uint8_t matriz 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 intérprete

Criamos um tflite::MicroInterpreter exemplo, passando as variáveis criadas anteriormente:

tflite::MicroInterpreter interpreter(model, resolver, tensor_arena,
                                     tensor_arena_size, error_reporter);

9. Alocar tensores

Nós dizemos que o intérprete alocar memória do tensor_arena para tensores do modelo:

interpreter.AllocateTensors();

10. Valide a forma de entrada

O MicroInterpreter instância pode fornecer-nos com um ponteiro para tensor de entrada do modelo, chamando .input(0) , em que 0 representa a primeira (e única) de entrada tensor:

  // 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 o 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 de enumeração kTfLiteFloat32 é uma referência a um dos tipos de dados 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, da seguinte maneira:

input->data.f[0] = 0.;

Neste caso, nós introduzir um valor de ponto flutuante que representa 0 .

12. Execute o modelo

Para executar o modelo, podemos chamar Invoke() em nosso tflite::MicroInterpreter exemplo:

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 valores possíveis de TfLiteStatus , definidos em common.h , são kTfLiteOk e kTfLiteError .

O código a seguir afirma que o valor é kTfLiteOk , significando inferência foi executado com êxito.

TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, invoke_status);

13. Obtenha a saída

Tensor de saída do modelo podem ser obtidas pelo telefone output(0) sobre o tflite::MicroInterpreter , onde 0 representa a primeira (e única) 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, chamamos 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);

15. Leia o código do aplicativo

Depois de ter andado através deste teste de unidade, você deve ser capaz de entender o código do aplicativo do exemplo, localizado na main_functions.cc . Ele segue um processo semelhante, mas gera um valor de entrada com base em quantas inferências foram executadas e chama uma função específica do dispositivo que exibe a saída do modelo para o usuário.