מדידת ביצועים

כלים להשוואה

כלי ההשוואה לשוק של TensorFlow Lite מודדים ומחשבים כרגע נתונים סטטיסטיים עבור מדדי הביצועים החשובים הבאים:

• זמן אתחול
• זמן ההסקה של מצב התחממות
• זמן הסקת מסקנות למצב יציב
• שימוש בזיכרון במהלך זמן האתחול
• שימוש כולל בזיכרון

כלי ההשוואה לשוק זמינים כאפליקציות השוואה ל-Android ול-iOS, וכקבצים בינאריים מקוריים של שורת הפקודה, ולכולם יש לוגיקה בסיסית למדידת ביצועים. שימו לב שהאפשרויות הזמינות ופורמטים של פלט מעט שונים בגלל ההבדלים בסביבת זמן הריצה.

אפליקציית בנצ'מרק ל-Android

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

לאפליקציה הזו של השוואה לשוק ל-Android אין ממשק משתמש. מתקינים ומפעילים אותו באמצעות הפקודה adb, ומאחזרים את התוצאות באמצעות הפקודה adb logcat.

הורדה או בנייה של האפליקציה

אפשר להוריד את אפליקציות ההשוואה לשוק של Android שפותחו מראש בלילה באמצעות הקישורים הבאים:

• android_aarch64
• android_arm

לגבי אפליקציות השוואה לשוק ל-Android שתומכות בפעולות TF באמצעות הענקת גישה גמישה, אפשר להשתמש בקישורים הבאים:

• android_aarch64
• android_arm

אפשר גם לפתח את האפליקציה מהמקור בעזרת instructions.

הכנת נקודת השוואה

לפני שמפעילים את אפליקציית ההשוואה לשוק, צריך להתקין את האפליקציה ולהעביר את קובץ המודל למכשיר באופן הבא:

adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp

הפעלת השוואה לשוק

adb shell am start -S \
  -n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
  --es args '"--graph=/data/local/tmp/your_model.tflite \
              --num_threads=4"'

graph הוא פרמטר חובה.

• graph: string
  נתיב לקובץ המודל של TFLite.

אפשר לציין פרמטרים אופציונליים נוספים להפעלת ההשוואה לשוק.

• num_threads: int (ברירת מחדל=1)
  מספר השרשורים שבהם צריך להשתמש להפעלת תרגום TFLite.
• use_gpu: bool (ברירת מחדל=false)
  שימוש בהענקת גישה ל-GPU.
• use_xnnpack: bool (ברירת מחדל=false)
  משתמשים בהענקת גישה ל-XNNPACK.

בהתאם למכשיר שבו משתמשים, יכול להיות שחלק מהאפשרויות לא יהיו זמינות או שאין להן השפעה. אפשר לקרוא על פרמטרים עוד פרמטרים של ביצועים שאפשר להריץ עם אפליקציית ההשוואה לשוק.

מציגים את התוצאות באמצעות הפקודה logcat:

adb logcat | grep "Inference timings"

תוצאות ההשוואה לשוק מדווחות כך:

... tflite  : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2

ערך בינארי מקורי לנקודת השוואה

הכלי השוואה לשוק מסופק גם כ-benchmark_model בינארי מקורי. אפשר להפעיל את הכלי הזה משורת פקודה של מעטפת ב-Linux, ב-Mac, במכשירים מוטמעים ובמכשירי Android.

הורדה או יצירה של הקובץ הבינארי

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

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

לקבצים בינאריים שנוצרו מראש מדי לילה ותומכים ב-TF ops דרך Flex delegate, תוכלו להשתמש בקישורים הבאים:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

אפשר גם ליצור את הקובץ הבינארי של נקודת ההשוואה המקורית מ-source במחשב.

bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model

כדי לפתח באמצעות 'צרור הכלים של Android NDK', קודם צריך להגדיר את סביבת ה-build לפי ההוראות במדריך הזה, או להשתמש בתמונת ה-docker כפי שמתואר במדריך הזה.

bazel build -c opt --config=android_arm64 \
  //tensorflow/lite/tools/benchmark:benchmark_model

הפעלת השוואה לשוק

כדי להריץ את נקודות ההשוואה במחשב, הפעילו את הקובץ הבינארי מהמעטפת.

path/to/downloaded_or_built/benchmark_model \
  --graph=your_model.tflite \
  --num_threads=4

תוכלו להשתמש באותה קבוצה של פרמטרים שהוזכרה למעלה עם הקובץ הבינארי המקורי של שורת הפקודה.

פעולות של מודל ליצירת פרופילים

המודל הבינארי של המודל במבחן השוואת הביצועים גם מאפשר ליצור פרופיל של פעולות ולקבל את זמני הביצוע של כל אופרטור. כדי לעשות זאת, מעבירים את הדגל --enable_op_profiling=true ל-benchmark_model במהלך ההפעלה. הפרטים מופיעים כאן.

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

הוא גם מספק קובץ בינארי נוח ופשוט ל-C++ כדי לבצע השוואה בין כמה אפשרויות של ביצועים בהפעלה יחידה. הבינארי הזה נוצר על סמך כלי ההשוואה לשוק שהוזכר למעלה, שיכול ליצור נקודת השוואה רק לגבי אפשרות ביצועים אחת בכל פעם. הם חולקים את אותו תהליך build/התקנה/הפעלה, אבל שם היעד של BUILD של הקובץ הבינארי הזה הוא benchmark_model_performance_options ונדרשים כמה פרמטרים נוספים. פרמטר חשוב לקובץ הבינארי הזה הוא:

perf_options_list: string (default='all')
רשימה מופרדת בפסיקים של אפשרויות ביצועים ב-TFLite כנקודת השוואה.

אפשר לקבל קבצים בינאריים מוכנים מראש לכלי הזה לפי הפירוט הבא:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

אפליקציית בנצ'מרק ל-iOS

כדי להפעיל נקודות השוואה במכשיר iOS, צריך לפתח את האפליקציה מ-source. צריך לשמור את קובץ המודל של TensorFlow Lite בספרייה benchmark_data של עץ המקור ולשנות את הקובץ benchmark_params.json. הקבצים האלה נארזים באפליקציה, והאפליקציה קוראת נתונים מהספרייה. אפשר לעיין בהוראות מפורטות באפליקציה ל-iOS.

נקודות השוואה של ביצועים למודלים ידועים

בקטע הזה מפורטות נקודות ההשוואה של הביצועים של TensorFlow Lite כשמפעילים מודלים מוכרים בחלק ממכשירי Android ו-iOS.

נקודות השוואה לביצועים ב-Android

המספרים האלה ביחס לנקודת ההשוואה לביצועים נוצרו באמצעות הקובץ הבינארי של נקודת ההשוואה לשוק.

בנקודות השוואה של Android, הזיקה למעבד (CPU) מוגדרת לשימוש בליבות גדולות של המכשיר כדי לצמצם את השונות (לפרטים).

ההנחה היא שמודלים הורדו וחילקו את הקבצים לספרייה /data/local/tmp/tflite_models. הקוד הבינארי של נקודת ההשוואה נוצר לפי ההוראות האלה, וההנחה נמצאת בספרייה /data/local/tmp.

כדי להפעיל את ההשוואה לשוק:

adb shell /data/local/tmp/benchmark_model \
  --num_threads=4 \
  --graph=/data/local/tmp/tflite_models/${GRAPH} \
  --warmup_runs=1 \
  --num_runs=50

כדי לפעול עם גישה ל-GPU, יש להגדיר --use_gpu=true.

ערכי הביצועים הבאים נמדדים ב-Android 10.

שם דגם	מכשיר	מעבד (CPU), 4 שרשורים	GPU
Mobilenet_1.0_224(float)	Pixel 3	23.9 אלפיות השנייה	6.45 אלפיות השנייה
	Pixel 4	14.0 אלפיות השנייה	9.0 אלפיות השנייה
Mobilenet_1.0_224 (כמות)	Pixel 3	13.4 אלפיות השנייה	---
	Pixel 4	5.0 אלפיות השנייה	---
NASNet mobile	Pixel 3	56 אלפיות השנייה	---
	Pixel 4	34.5 אלפיות השנייה	---
SqueezeNet	Pixel 3	35.8 אלפיות השנייה	9.5 אלפיות השנייה
	Pixel 4	23.9 אלפיות השנייה	11.1 אלפיות השנייה
Inception_ResNet_V2	Pixel 3	422 אלפיות השנייה	99.8 אלפיות השנייה
	Pixel 4	272.6 אלפיות השנייה	87.2 אלפיות השנייה
Inception_V4	Pixel 3	486 אלפיות השנייה	93 אלפיות השנייה
	Pixel 4	324.1 אלפיות השנייה	97.6 אלפיות השנייה

נקודות השוואה לביצועים ב-iOS

המספרים האלה ביחס לנקודת ההשוואה של הביצועים נוצרו באמצעות האפליקציה להשוואת ביצועים של iOS.

כדי להפעיל נקודות השוואה של iOS, בוצע שינוי באפליקציה של נקודת ההשוואה כך שהיא כוללת את המודל המתאים. כמו כן, הערך של benchmark_params.json הוגדר ל-num_threads כ-2. כדי להשתמש בגישה ל-GPU, נוספו גם האפשרויות "use_gpu" : "1" ו-"gpu_wait_type" : "aggressive" ל-benchmark_params.json.

שם דגם	מכשיר	מעבד, 2 שרשורים	GPU
Mobilenet_1.0_224(float)	iPhone XS	14.8 אלפיות השנייה	3.4 אלפיות השנייה
Mobilenet_1.0_224 (כמות)	iPhone XS	11 אלפיות השנייה	---
NASNet mobile	iPhone XS	30.4 אלפיות השנייה	---
SqueezeNet	iPhone XS	21.1 אלפיות השנייה	15.5 אלפיות השנייה
Inception_ResNet_V2	iPhone XS	261.1 אלפיות השנייה	45.7 אלפיות השנייה
Inception_V4	iPhone XS	309 אלפיות השנייה	54.4 אלפיות השנייה

מעקב אחר פעולות פנימיות של TensorFlow Lite

מעקב אחר רכיבים פנימיים של TensorFlow Lite ב-Android

כלי מעקב ב-Android יכולים לתעד אירועים פנימיים של רכיב התרגום TensorFlow Lite של אפליקציה ל-Android. הם זהים לאירועים ב-Android Trace API, כך שהאירועים שתועדו מקוד Java/Kotlin מוצגים יחד עם אירועים פנימיים של TensorFlow Lite.

דוגמאות לאירועים:

• הפעלת המפעיל
• שינוי תרשים על ידי משתמש בעל גישה
• הקצאה ב-Tensor

המדריך הזה כולל בין האפשרויות השונות ללכידת נתוני מעקבים, כולל הכלי 'פרופיל המעבד (CPU) ב-Android' ואפליקציית System Trace. תוכלו להיעזר בכלי שורת הפקודה Perfetto או בכלי שורת הפקודה של System.

הוספת אירועי מעקב בקוד Java

זהו קטע קוד מהאפליקציה לדוגמה של סיווג תמונות. רכיב התרגום של TensorFlow Lite פועל בקטע recognizeImage/runInference. השלב הזה הוא אופציונלי, אבל הוא עוזר לשים לב איפה מתבצעת קריאה להסקה.

  Trace.beginSection("recognizeImage");
  ...
  // Runs the inference call.
  Trace.beginSection("runInference");
  tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
  Trace.endSection();
  ...
  Trace.endSection();

הפעלת מעקב ב-TensorFlow Lite

כדי להפעיל את המעקב TensorFlow Lite, צריך להגדיר את מאפיין המערכת של Android debug.tflite.trace ל-1 לפני שמפעילים את האפליקציה ל-Android.

adb shell setprop debug.tflite.trace 1

אם המאפיין הזה הוגדר כשכלי התרגום של TensorFlow Lite מופעל, יתבצע מעקב אחרי אירועים מרכזיים (למשל, הפעלת אופרטור) מהמתרגם.

אחרי שתסיימו לתעד את כל המעקבים, תוכלו להשבית את המעקב על ידי הגדרת ערך המאפיין ל-0.

adb shell setprop debug.tflite.trace 0

הכלי לניתוח ביצועי ה-CPU ב-Android Studio

תוכלו לתעד את המעקבים באמצעות הכלי לניתוח ביצועי ה-CPU ב-Android Studio על ידי ביצוע השלבים הבאים:

1. בתפריטים העליונים בוחרים באפשרות הפעלה > 'אפליקציה' בפרופיל.

2. לוחצים במקום כלשהו בציר הזמן של המעבד (CPU) כשמופיע החלון Profiler.

3. יש לבחור באפשרות 'שיחות מערכת מעקב' בין מצבי יצירת פרופילים של המעבד (CPU).

   

4. יש ללחוץ על לחצן ההקלטה.

5. לוחצים על הלחצן 'עצירה'.

6. בודקים את תוצאת המעקב.

   

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

אפליקציה למעקב אחרי מערכת

לתעד עקבות בלי Android Studio על ידי ביצוע השלבים המפורטים באפליקציה למעקב אחר מערכת.

בדוגמה הזו, אותם אירועי TFLite תועדו ונשמרו בפורמט Perfetto או Systrace, בהתאם לגרסת Android. את קובצי המעקב שתועדו ניתן לפתוח בממשק המשתמש של Perfetto.

מעקב אחר רכיבים פנימיים של TensorFlow Lite ב-iOS

אפשר לתעד אירועים פנימיים של רכיב התרגום TensorFlow Lite של אפליקציה ל-iOS באמצעות הכלי Instruments שכלול ב-Xcode. אלו אירועי החתימה ב-iOS, כך שהאירועים שתועדו מקוד Swift/Objective-C מוצגים יחד עם אירועים פנימיים של TensorFlow Lite.

דוגמאות לאירועים:

• הפעלת המפעיל
• שינוי תרשים על ידי משתמש בעל גישה
• הקצאה ב-Tensor

הפעלת מעקב ב-TensorFlow Lite

כדי להגדיר את משתנה הסביבה debug.tflite.trace, פועלים לפי השלבים הבאים:

1. בתפריטים העליונים של Xcode, בוחרים באפשרות מוצר > סכימה > עריכת סכימה....

2. לחץ על 'פרופיל' בחלונית השמאלית.

3. מבטלים את הבחירה בתיבת הסימון 'שימוש בארגומנטים ומשתני סביבה של הפעולה'.

4. מוסיפים debug.tflite.trace בקטע 'משתני סביבה'.

   

אם רוצים להחריג אירועי TensorFlow Lite במהלך יצירת פרופיל של האפליקציה ל-iOS, צריך להשבית את המעקב על ידי הסרת משתנה הסביבה.

כלי XCode

לתיעוד עקבות יש לפעול לפי השלבים הבאים:

1. בתפריטים העליונים של Xcode, בוחרים באפשרות מוצר > פרופיל.

2. לוחצים על Logging בין תבניות יצירת הפרופילים כשכלי המכשירים מופעל.

3. יש ללחוץ על הלחצן 'התחלה'.

4. לוחצים על הלחצן 'עצירה'.

5. צריך ללחוץ על 'os_signpost' כדי להרחיב את הפריטים של מערכת המשנה של OS Logging.

6. לוחצים על 'org.tensorflow.lite' מערכת המשנה ל-OS Logging של מערכת ההפעלה.

7. בודקים את תוצאת המעקב.

   

בדוגמה הזו אפשר לראות את ההיררכיה של אירועים ונתונים סטטיסטיים לכל זמן של אופרטור.

שימוש בנתוני המעקב

נתוני המעקב מאפשרים לכם לזהות צווארי בקבוק בביצועים.

ריכזנו כאן כמה דוגמאות לתובנות שתוכלו לקבל מהכלי לניתוח ביצועים (profiler) ופתרונות אפשריים לשיפור הביצועים:

• אם מספר ליבות המעבד (CPU) הזמינות קטן ממספר השרשורים של ההסקה, התקורה של תזמון המעבד (CPU) יכולה להוביל לביצועים משניים. אתם יכולים לתזמן מחדש משימות אחרות שדורשות מעבד (CPU) באפליקציה שלכם כדי למנוע חפיפה עם ההסקה של המודל או לשנות את מספר ה-threads של מתורגמן.
• אם האופרטורים לא הוענקו באופן מלא, חלקים מסוימים מתרשים המודל יופעלו במעבד (CPU) ולא בהאצת החומרה הצפויה. אפשר להחליף את האופרטורים שלא נתמכים באופרטורים נתמכים דומים.