Помогают защитить Большой Барьерный Риф с TensorFlow на Kaggle Присоединяйтесь вызов

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

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

Пример Hello World

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

Сквозной рабочий процесс включает следующие шаги:

  1. Поезд модели (в Python): A jupyter ноутбук на поезд, обращенный и оптимизировать модель для использования на устройстве.
  2. Запуск умозаключение (в C ++ 11): блок испытания конца в конец , который работает Умозаключение на модели с использованием C ++ библиотеки .

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

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

Подробнее о поддерживаемых платформах в TensorFlow Lite для микроконтроллеров .

Обучить модель

Использование Google Colaboratory для тренировать собственную модель . Для получения более подробной информации, обратитесь к README.md :

Привет, мир, обучение README.md

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

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

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

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

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

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

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

2. Добавьте заголовок модели.

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

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

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

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

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

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

tflite::AllOpsResolver resolver;

В AllOpsResolver загружает все операции , доступных в TensorFlow Lite для микроконтроллеров, который использует много памяти. Поскольку данная модель будет использовать только подмножество этих операций, рекомендуется, чтобы реальные приложения загружали только те операции, которые необходимы.

Это делается с помощью другого класса, MicroMutableOpResolver . Вы можете увидеть , как использовать его в микро речевого примера в micro_speech_test.cc .

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 является ссылкой на один из типов данных TensorFlow Lite, и определяется в 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);

15. Прочтите код приложения.

После того, как вы прошли через это модульное тестирование, вы должны быть в состоянии понять код приложения на примере, расположенном в main_functions.cc . Он следует аналогичному процессу, но генерирует входное значение в зависимости от того, сколько логических выводов было выполнено, и вызывает специфичную для устройства функцию, которая отображает выходные данные модели пользователю.