เอกสารนี้อธิบายวิธีฝึกโมเดลและเรียกใช้การอนุมานโดยใช้ไมโครคอนโทรลเลอร์
ตัวอย่าง Hello World
ตัวอย่าง Hello World ออกแบบมาเพื่อแสดงพื้นฐานที่แท้จริงของการใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ เราฝึกและเรียกใช้โมเดลที่จำลองฟังก์ชัน sine กล่าวคือ จะใช้ตัวเลขเดียวเป็นอินพุตและเอาต์พุตค่า sine ของตัวเลข เมื่อนำไปใช้กับไมโครคอนโทรลเลอร์ ระบบจะใช้การคาดคะเนเพื่อกะพริบไฟ LED หรือควบคุมภาพเคลื่อนไหว
เวิร์กโฟลว์ตั้งแต่ต้นจนจบเกี่ยวข้องกับขั้นตอนต่อไปนี้
- ฝึกโมเดล (ใน Python): ไฟล์ Python เพื่อฝึก แปลง และเพิ่มประสิทธิภาพโมเดลสำหรับการใช้งานในอุปกรณ์
- เรียกใช้การอนุมาน (ใน C++ 17): การทดสอบหน่วยโฆษณาจากต้นทางถึงปลายทางที่ทำการอนุมานโมเดลโดยใช้ไลบรารี C++
ซื้ออุปกรณ์ที่รองรับ
แอปพลิเคชันตัวอย่างที่เราจะใช้ได้รับการทดสอบในอุปกรณ์ต่อไปนี้
- Arduino Nano 33 BLE Sense (ใช้ Arduino IDE)
- SparkFun Edge (อาคารโดยตรงจากแหล่งที่มา)
- ชุด Discovery STM32F746 (ที่ใช้ Mbed)
- Adafruit EdgeBadge (ใช้ Arduino IDE)
- Adafruit TensorFlow Lite สำหรับชุดไมโครคอนโทรลเลอร์ (ใช้ Arduino IDE)
- Adafruit Circuit Playground Bluefruit (ใช้ Arduino IDE)
- Espressif ESP32-DevKitC (โดยใช้ ESP IDF)
- Espressif ESP-EYE (โดยใช้ ESP IDF)
ดูข้อมูลเพิ่มเติมเกี่ยวกับแพลตฟอร์มที่รองรับใน TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์
ฝึกการใช้งานโมเดล
ใช้ 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
ดังนี้
ส่วนต่อไปนี้จะอธิบายตัวอย่าง evaluate_test.cc
ซึ่งเป็นการทดสอบ 1 หน่วยซึ่งแสดงวิธีเรียกใช้การอนุมานโดยใช้ 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 LiteFlatBuffer
version.h
ให้ข้อมูลการกำหนดเวอร์ชันสำหรับสคีมา TensorFlow Lite
2. รวมส่วนหัวของรุ่น
อินเทอร์พรีเตอร์ของ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์คาดว่าระบบจะจัดเตรียมโมเดลนี้เป็นอาร์เรย์ C++ โมเดลนี้กำหนดไว้ในไฟล์ model.h
และ model.cc
ส่วนหัวจะรวมอยู่ในบรรทัดต่อไปนี้:
#include "tensorflow/lite/micro/examples/hello_world/model.h"
3. ใส่ส่วนหัวของเฟรมเวิร์กการทดสอบหน่วย
เราได้รวมเฟรมเวิร์กการทดสอบหน่วยของ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์โดยใส่บรรทัดต่อไปนี้เพื่อสร้างการทดสอบ 1 หน่วย
#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 = µ_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 นี้เพื่อยืนยันว่ารูปร่างและชนิดของ 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
เป็นการอ้างอิงถึงประเภทข้อมูล TensorFlow Lite แบบใดแบบหนึ่งและมีการกำหนดไว้ใน 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 เอาต์พุตแรก (และเท่านั้น)
ในตัวอย่างนี้ เอาต์พุตของโมเดลคือค่าทศนิยมค่าเดียวที่อยู่ใน 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);