תחילת העבודה עם מיקרו-בקרים

המסמך הזה מסביר איך לאמן מודל ולהריץ הסקת מסקנות באמצעות מיקרו-בקר.

הדוגמה 'שלום עולם'

שלום עולם נועדה להדגים את היסודות המוחלטים של שימוש ב-LiteRT למיקרו-בקרים. אנחנו מאמנים ומפעילים מודל שמשכפל פונקציית סינוס, כלומר, הוא לוקח מספר אחד כקלט, ומפיק פלט של המספר sine. כשפורסים אותו מיקרו-בקר, החיזויים שלו משמשים להבהוב נורות LED או לשליטה אנימציה.

תהליך העבודה מקצה לקצה כולל את השלבים הבאים:

  1. אימון מודל (ב-Python): קובץ python לאימון, המרה ולבצע אופטימיזציה של מודל לשימוש במכשיר.
  2. הסקת מסקנות (ב-C++ 17): בדיקה של היחידה מקצה לקצה מפעיל את ההסקה על המודל באמצעות ספריית C++.

רכישת מכשיר נתמך

האפליקציה לדוגמה שבה נשתמש נבדקה במכשירים הבאים:

מידע נוסף על פלטפורמות נתמכות זמין בקישור הבא: LiteRT למיקרו-בקרים.

אימון מודל

כדאי להשתמש train.py לאימון מודלים של "שלום עולם" לזיהוי 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 בדיקת יחידה שמדגימה איך להריץ מסקנות באמצעות 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"

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. מקצים Tensors

אנחנו מבקשים למתורגמן להקצות זיכרון מ-tensor_arena את Tensors של המודל:

interpreter.AllocateTensors();

10. אימות צורת הקלט

המופע של MicroInterpreter יכול לספק לנו מצביע אל את Tensor הקלט באמצעות קריאה ל-.input(0), כאשר 0 מייצג את הראשון (ורק) t e n s o r f l o w:

  // 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 הוא הפניה לאחד מערכים של LiteRT וגם מוגדרים common.h.

11. צריך להזין ערך לקלט

כדי לספק קלט למודל, אנחנו מגדירים את התוכן של img_tensor. ככה:

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

במקרה הזה, מזינים ערך של נקודה צפה (floating-point) שמייצג את 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 מייצג את הפלט הראשון (והרק) את Tensor.

בדוגמה, הפלט של המודל הוא ערך יחיד של נקודה צפה (floating-point) בתוך t e n s o r f l o w:

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