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

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

ตัวอย่างของ Hello World

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

ขั้นตอนการทำงานตั้งแต่ต้นจบจะมีขั้นตอนต่อไปนี้

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

ดาวน์โหลดอุปกรณ์ที่รองรับ

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

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

ฝึกการใช้งานโมเดล

ใช้ train.py สำหรับการฝึกโมเดล Hello World สำหรับการจดจำ Sinwave

เรียกใช้: 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 การทดสอบ 1 หน่วยซึ่งสาธิตวิธีอนุมานโดยใช้ 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. รวมส่วนหัวของเฟรมเวิร์กยูนิตเทสต์

เพื่อสร้างการทดสอบ 1 หน่วย เราได้รวม 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

เราจะบอกให้ล่ามจัดสรรหน่วยความจำจาก tensor_arena สำหรับ Tensor ของโมเดล:

interpreter.AllocateTensors();

10. ตรวจสอบความถูกต้องของรูปร่างอินพุต

อินสแตนซ์ MicroInterpreter สามารถให้ตัวชี้เมาส์ไปยังฟังก์ชันของโมเดล ป้อน Tensor โดยเรียกใช้ .input(0) โดยที่ 0 จะแสดงรายการแรก (และเท่านั้น) Tensor อินพุต:

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

จากนั้นเราจะตรวจสอบ Tensor นี้เพื่อยืนยันว่ารูปร่างและชนิดของโมเดลคือสิ่งที่เราเป็น คาดหวัง:

// 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 เป็นการอ้างอิงไปยัง LiteRT ค่าใดค่าหนึ่ง ประเภทข้อมูล และมีการกำหนดไว้ใน common.h

11. ระบุค่าอินพุต

เรากำหนดเนื้อหาของ Tensor อินพุต ดังนี้ ดังต่อไปนี้:

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. รับเอาต์พุต

รับ Tensor เอาต์พุตของโมเดลได้โดยเรียกใช้ output(0) ใน tflite::MicroInterpreter โดยที่ 0 แสดงถึงเอาต์พุตแรก (เท่านั้น) Tensor

ในตัวอย่างนี้ เอาต์พุตของโมเดลคือค่าทศนิยม 1 จุดที่มี ภายใน Tensor แบบ 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);

เราสามารถอ่านค่าได้โดยตรงจาก Tensor เอาต์พุตและยืนยันว่านี่คือสิ่งที่ ซึ่งเราคาดว่า

// 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. เรียกใช้การอนุมานอีกครั้ง

ส่วนที่เหลือของโค้ดจะเรียกใช้การอนุมานหลายครั้ง ในแต่ละกรณี เราจะกำหนดค่าให้กับ Tensor อินพุต เรียกใช้ล่าม และอ่าน ผลลัพธ์จาก Tensor เอาต์พุต:

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