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

כלים להשוואה

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

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

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

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

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

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

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

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

• android_aarch64
• android_arm

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

• 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 (ברירת המחדל)
  שימוש בהענקת גישה ל-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 דרך Flex נציג, השתמשו בקישורים הבאים:

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

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

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

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

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 (ברירת המחדל 'הכול')
רשימה מופרדת בפסיקים של אפשרויות ביצועים של TFLite להשוואה.

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

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

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

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

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

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

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

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

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

ההנחה היא שהמודלים הורדו וחולצו אל קובץ ה-ZIP ספריית /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.

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

מעקב אחר רכיבים פנימיים של LiteRT

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

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

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

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

המדריך הזה עוסק באפשרויות השונות לתיעוד מעקבים, הכלי לניתוח ביצועי המעבד (CPU) ב-Studio ואפליקציית System Tracing. פרטים נוספים כלי שורת הפקודה Perfetto או כלי שורת הפקודה של Systrace לאפשרויות אחרות.

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

זהו קטע קוד מתוך סיווג תמונות אפליקציה לדוגמה. רכיב התרגום ב-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. בוחרים באפשרות הפעלה > פרופיל 'אפליקציה' מהתפריטים העליונים.

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

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

   

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

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

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

   

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

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

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

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

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

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

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

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

הפעלה של מעקב LiteRT

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

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

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

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

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

   

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

כלי XCode

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

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

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

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

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

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

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

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

   

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

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

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

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

• אם מספר ליבות המעבד (CPU) הזמינות קטן ממספר ההסקה אז התקורה של התזמון של המעבד (CPU) עלולה להוביל לביצועים נמוכים. אתם יכולים לתזמן מחדש משימות אחרות שצורכות הרבה מעבד (CPU) באפליקציה שלכם, כדי להימנע לחפוף עם ההֶקֵּשׁ של המודל או לשנות את מספר התרגום שרשורים.
• אם האופרטורים לא מוקצים באופן מלא, אז חלקים מסוימים בתרשים המודל מופעלות על המעבד (CPU) ולא על מאיץ החומרה הצפוי. שלך יכול להחליף את האופרטורים שלא נתמכים באופרטורים נתמכים דומים.