ขอขอบคุณที่เข้าร่วม Google I/O ดูเซสชั่นทั้งหมดตามความต้องการ ดูตามความต้องการ

เริ่มต้นใช้งานไมโครคอนโทรลเลอร์

เอกสารนี้อธิบายวิธีฝึกโมเดลและเรียกใช้การอนุมานโดยใช้ไมโครคอนโทรลเลอร์

ตัวอย่าง Hello World

ตัวอย่าง Hello World ออกแบบมาเพื่อสาธิตพื้นฐานการใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ เราฝึกและรันโมเดลที่จำลองฟังก์ชันไซน์ กล่าวคือ จะใช้ตัวเลขเดียวเป็นอินพุต และเอาต์พุตเป็นค่า ไซน์ ของตัวเลข เมื่อปรับใช้กับไมโครคอนโทรลเลอร์ การคาดคะเนจะถูกใช้เพื่อกะพริบไฟ LED หรือควบคุมภาพเคลื่อนไหว

เวิร์กโฟลว์แบบ end-to-end เกี่ยวข้องกับขั้นตอนต่อไปนี้:

  1. ฝึกโมเดล (ใน Python): โน้ตบุ๊ก jupyter เพื่อฝึก แปลง และปรับแต่งโมเดลสำหรับการใช้งานบนอุปกรณ์
  2. รันการอนุมาน (ใน C++ 17): การทดสอบหน่วยแบบ end-to-end ที่รันการอนุมานบนโมเดลโดยใช้ ไลบรารี C++

รับอุปกรณ์ที่รองรับ

แอปพลิเคชันตัวอย่างที่เราจะใช้ได้รับการทดสอบบนอุปกรณ์ต่อไปนี้:

เรียนรู้เพิ่มเติมเกี่ยวกับแพลตฟอร์มที่รองรับใน TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์

ฝึกโมเดล

ใช้ Google Collaboratory เพื่อ ฝึกโมเดลของคุณเอง สำหรับรายละเอียดเพิ่มเติม โปรดดูที่ README.md :

สวัสดีชาวโลก การฝึกอบรม README.md

เรียกใช้การอนุมาน

ในการเรียกใช้โมเดลบนอุปกรณ์ของคุณ เราจะดำเนินการตามคำแนะนำใน README.md :

สวัสดีชาวโลก README.md

ส่วนต่อไปนี้จะอธิบายถึง evaluate_test.cc ของตัวอย่าง ซึ่งเป็นการทดสอบหน่วยซึ่งสาธิตวิธีเรียกใช้การอนุมานโดยใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ มันโหลดโมเดลและเรียกใช้การอนุมานหลายครั้ง

1. รวมส่วนหัวของไลบรารี

หากต้องการใช้ไลบรารี TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ เราต้องรวมไฟล์ส่วนหัวต่อไปนี้:

#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 มีสคีมาสำหรับรูปแบบไฟล์โมเดล TensorFlow Lite FlatBuffer
  • version.h ให้ข้อมูลการกำหนดเวอร์ชันสำหรับสคีมา TensorFlow Lite

2. ใส่ส่วนหัวของโมเดล

ตัวแปล TensorFlow Lite for Microcontrollers คาดหวังว่าโมเดลจะได้รับเป็นอาร์เรย์ 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 array, 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 ต้องการพารามิเตอร์เทมเพลตที่ระบุจำนวน ops ที่จะลงทะเบียน ฟังก์ชัน RegisterOps จะลงทะเบียน ops ด้วยตัวแก้ไข

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

ค่า enum 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 หมายถึงเอาต์พุตเทนเซอร์ตัวแรก (และตัวเดียว)

ในตัวอย่าง เอาต์พุตของโมเดลคือค่าทศนิยมเดียวที่อยู่ภายในเทนเซอร์ 2 มิติ:

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