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

כלי השוואה לשוק

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

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

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

קובץ בינארי מוכן מראש של נקודת השוואה (באמצעות CompiledModel API)

יש שתי אפשרויות לשימוש בכלי ההשוואה לשוק עם Android. אחד מהם הוא קובץ בינארי של מדד ביצועים מקורי (מבוסס על CompiledModel API) והשני הוא אפליקציית מדד ביצועים ל-Android (מבוססת על Interpreter API). כלי ההשוואה LiteRT מסופק כקובץ בינארי מובנה benchmark_model. אפשר להריץ את הכלי הזה משורת פקודה של מעטפת ב-Linux,‏ macOS, ‏ Windows, ‏ Raspberry Pi, במכשירים מוטמעים ובמכשירי Android עם הפעלת האצת GPU.

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

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

• linux_x86_64
• linux_arm64
• android_arm64
• macos_arm64
• windows_x86_64

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

bazel build -c opt //litert/tools:benchmark_model

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

bazel build -c opt --config=android_arm64 \
  //litert/tools:benchmark_model

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

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

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

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

GPU Accelerator

הקבצים הבינאריים המוכנים מראש כוללים את LiteRT GPU Accelerator החדש. הוא תומך ב-OpenCL וב-WebGPU שמגובה על ידי Vulkan‏ (Linux),‏ Metal‏ (MacOS) ו-Direct3D‏ (Windows).

כדי להשתמש ב-GPU Accelerator, מעבירים את הדגל --use_gpu=true.

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

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

אפליקציית השוואה (benchmark) ל-Android (באמצעות Interpreter API)

מסופקת גם אפליקציית השוואה (benchmark) ל-Android שמבוססת על v1 Interpreter API. המדד הזה משקף בצורה טובה יותר את הביצועים של המודל באפליקציית Android. המספרים מכלי ההשוואה עדיין יהיו שונים מעט מהמספרים שיתקבלו כשמריצים הסקה עם המודל באפליקציה בפועל.

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

הורדה או פיתוח של האפליקציה

אפשר להוריד את אפליקציות ההשוואה (benchmark) ל-Android שנוצרות מראש מדי לילה באמצעות הקישורים הבאים:

• android_aarch64
• android_arm

לגבי אפליקציות להשוואה (benchmark) ל-Android שתומכות בפעולות TF באמצעות Flex delegate, אפשר להשתמש בקישורים הבאים:

• android_aarch64
• android_arm

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

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

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

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 delegate.

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

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

adb logcat | grep "Inference timings"

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

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

אפליקציית השוואה ל-iOS

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

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

בקטע הזה מפורטים מדדי ביצועים של LiteRT כשמריצים מודלים מוכרים במכשירי 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.

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

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

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

מעקב אחר הפעולות הפנימיות של LiteRT

מעקב אחר רכיבי LiteRT פנימיים ב-Android

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

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

• הפעלת אופרטור
• שינוי הגרף על ידי נציג
• הקצאת טנסור

במדריך הזה מוסבר על כלי פרופיל המעבד (CPU) של Android Studio ועל אפליקציית מעקב המערכת. כדי לקבל מידע על אפשרויות אחרות, אפשר לעיין בכלי שורת הפקודה של Perfetto או בכלי שורת הפקודה של Systrace.

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

זהו קטע קוד מאפליקציית הדוגמה Image Classification. מפענח LiteRT פועל בקטע recognizeImage/runInference. השלב הזה הוא אופציונלי, אבל הוא מועיל כדי לזהות איפה מתבצעת קריאת ההסקה.

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

הפעלת מעקב LiteRT

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

adb shell setprop debug.tflite.trace 1

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

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

adb shell setprop debug.tflite.trace 0

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

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

1. בתפריטים העליונים, בוחרים באפשרות Run > Profile 'app' (הפעלה > פרופיל 'אפליקציה').

2. כשחלון הכלי ליצירת פרופילים מופיע, לוחצים על ציר הזמן של CPU.

3. בוחרים באפשרות Trace System Calls (מעקב אחרי קריאות למערכת) מבין מצבי פרופיל ה-CPU.

   

4. לוחצים על כפתור ההקלטה.

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

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

   

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

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

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

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

מעקב אחר פרטים פנימיים של LiteRT ב-iOS

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

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

• הפעלת אופרטור
• שינוי הגרף על ידי נציג
• הקצאת טנסור

הפעלת מעקב LiteRT

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

1. בתפריטים העליונים של Xcode, בוחרים באפשרות Product (מוצר) > Scheme (סכימה) > Edit Scheme…‎ (עריכת הסכימה…).

2. בחלונית הימנית, לוחצים על 'פרופיל'.

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

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

   

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

XCode Instruments

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

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

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

3. לוחצים על הכפתור 'התחלה'.

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

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

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

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

   

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

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

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

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

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