Начните работу с микроконтроллерами

В этом документе объясняется, как обучить модель и выполнить вывод с помощью микроконтроллера.

Пример «Привет, мир»

Пример Hello World предназначен для демонстрации абсолютных основ использования LiteRT для микроконтроллеров. Мы обучаем и запускаем модель, которая воспроизводит синусоидальную функцию, т. е. принимает на вход одно число и выводит значение синуса этого числа. При развертывании на микроконтроллере его прогнозы используются либо для мигания светодиодов, либо для управления анимацией.

Комплексный рабочий процесс включает в себя следующие этапы:

1. Обучение модели (на Python). Файл Python для обучения, преобразования и оптимизации модели для использования на устройстве.
2. Выполнить вывод (в C++ 17): сквозной модульный тест, который выполняет вывод для модели с использованием библиотеки C++ .

Получите поддерживаемое устройство

Пример приложения, которое мы будем использовать, был протестирован на следующих устройствах:

• Arduino Nano 33 BLE Sense (с использованием Arduino IDE)
• SparkFun Edge (сборка непосредственно из исходного кода)
• STM32F746 Комплект Discovery (с использованием Mbed)
• Adafruit EdgeBadge (с использованием Arduino IDE)
• Комплект Adafruit LiteRT для микроконтроллеров (с использованием Arduino IDE)
• Игровая площадка Adafruit Circuit Bluefruit (с использованием Arduino IDE)
• Espressif ESP32-DevKitC (с использованием ESP IDF)
• Espressif ESP-EYE (с использованием ESP IDF)

Узнайте больше о поддерживаемых платформах в LiteRT для микроконтроллеров .

Обучение модели

Используйте train.py для обучения модели hello world для распознавания синусоидальной волны.

Запустите: 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/

Выполнить вывод

Чтобы запустить модель на вашем устройстве, мы пройдемся по инструкциям в README.md :

Привет, мир README.md

В следующих разделах рассматривается пример evaluate_test.cc , модульный тест, который демонстрирует, как выполнить вывод с использованием LiteRT для микроконтроллеров. Он загружает модель и выполняет вывод несколько раз.

1. Включите заголовки библиотеки

Чтобы использовать библиотеку LiteRT для микроконтроллеров, мы должны включить следующие заголовочные файлы:

#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 предоставляет операции, используемые интерпретатором для запуска модели.
• micro_error_reporter.h выводит отладочную информацию.
• micro_interpreter.h содержит код для загрузки и запуска моделей.
• schema_generated.h содержит схему для формата файла модели LiteRT FlatBuffer .
• version.h предоставляет информацию о версии для схемы LiteRT.

2. Включите заголовок модели.

Интерпретатор LiteRT для микроконтроллеров ожидает, что модель будет предоставлена ​​в виде массива C++. Модель определена в файлах model.h и model.cc . Заголовок включается следующей строкой:

#include "tensorflow/lite/micro/examples/hello_world/model.h"

3. Включите заголовок платформы модульного тестирования.

Чтобы создать модульный тест, мы включаем среду модульного тестирования LiteRT для микроконтроллеров, включив следующую строку:

#include "tensorflow/lite/micro/testing/micro_test.h"

Тест определяется с помощью следующих макросов:

TF_LITE_MICRO_TESTS_BEGIN

TF_LITE_MICRO_TEST(LoadModelAndPerformInference) {
  . // add code here
  .
}

TF_LITE_MICRO_TESTS_END

Теперь мы обсудим код, включенный в макрос выше.

4. Настройте ведение журнала

Для настройки ведения журнала создается указатель tflite::ErrorReporter с использованием указателя на экземпляр tflite::MicroErrorReporter :

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

Эта переменная будет передана в интерпретатор, что позволит ему писать логи. Поскольку микроконтроллеры часто имеют различные механизмы журналирования, реализация tflite::MicroErrorReporter предназначена для настройки под ваше конкретное устройство.

5. Загрузите модель

В следующем коде модель создается с использованием данных из массива char g_model , который объявлен в model.h . Затем мы проверяем модель, чтобы убедиться, что ее версия схемы совместима с версией, которую мы используем:

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. Резолвер операций создания экземпляров

Объявлен экземпляр MicroMutableOpResolver . Это будет использоваться интерпретатором для регистрации и доступа к операциям, которые используются моделью:

using HelloWorldOpResolver = tflite::MicroMutableOpResolver<1>;

TfLiteStatus RegisterOps(HelloWorldOpResolver& op_resolver) {
  TF_LITE_ENSURE_STATUS(op_resolver.AddFullyConnected());
  return kTfLiteOk;

MicroMutableOpResolver требует параметра шаблона, указывающего количество операций, которые будут зарегистрированы. Функция RegisterOps регистрирует операции с помощью преобразователя.

HelloWorldOpResolver op_resolver;
TF_LITE_ENSURE_STATUS(RegisterOps(op_resolver));

7. Выделить память

Нам необходимо заранее выделить определенный объем памяти для входных, выходных и промежуточных массивов. Это предоставляется как массив uint8_t размером tensor_arena_size :

const int tensor_arena_size = 2 * 1024;
uint8_t tensor_arena[tensor_arena_size];

Требуемый размер будет зависеть от модели, которую вы используете, и, возможно, его придется определять экспериментальным путем.

8. Создание экземпляра интерпретатора

Мы создаем экземпляр tflite::MicroInterpreter , передавая созданные ранее переменные:

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

9. Выделение тензоров

Мы говорим интерпретатору выделить память из tensor_arena для тензоров модели:

interpreter.AllocateTensors();

10. Проверка формы ввода

Экземпляр MicroInterpreter может предоставить нам указатель на входной тензор модели, вызвав .input(0) , где 0 представляет первый (и единственный) входной тензор:

  // Obtain a pointer to the model's input tensor
  TfLiteTensor* input = interpreter.input(0);

Затем мы проверяем этот тензор, чтобы убедиться, что его форма и тип соответствуют нашим ожиданиям:

// 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);

Значение перечисления kTfLiteFloat32 является ссылкой на один из типов данных LiteRT и определено в common.h .

11. Введите входное значение

Чтобы предоставить входные данные модели, мы устанавливаем содержимое входного тензора следующим образом:

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

В этом случае мы вводим значение с плавающей запятой, представляющее 0 .

12. Запустите модель

Чтобы запустить модель, мы можем вызвать Invoke() в нашем экземпляре tflite::MicroInterpreter :

TfLiteStatus invoke_status = interpreter.Invoke();
if (invoke_status != kTfLiteOk) {
  TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed\n");
}

Мы можем проверить возвращаемое значение TfLiteStatus , чтобы определить, был ли запуск успешным. Возможные значения TfLiteStatus , определенные в common.h , — это kTfLiteOk и kTfLiteError .

Следующий код утверждает, что значение равно kTfLiteOk , что означает, что вывод был успешно выполнен.

TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, invoke_status);

13. Получите результат

Выходной тензор модели можно получить, вызвав output(0) в tflite::MicroInterpreter , где 0 представляет первый (и единственный) выходной тензор.

В этом примере выходные данные модели представляют собой одно значение с плавающей запятой, содержащееся в двумерном тензоре:

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);

Мы можем прочитать значение непосредственно из выходного тензора и утверждать, что это именно то, что мы ожидаем:

// 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. Запустите вывод еще раз

Оставшаяся часть кода выполняет вывод еще несколько раз. В каждом случае мы присваиваем значение входному тензору, вызываем интерпретатор и читаем результат из выходного тензора:

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);