נציגי TensorFlow Lite

מבוא

הנציגים מאפשרים האצת חומרה של דגמי TensorFlow Lite על ידי מינוף מאיצים במכשיר כגון ה-GPU ומעבד האותות הדיגיטלי (DSP) .

כברירת מחדל, TensorFlow Lite משתמש בגרעיני CPU המותאמים לסט ההוראות של ARM Neon . עם זאת, ה-CPU הוא מעבד רב-תכליתי שאינו בהכרח מותאם לאריתמטיקה הכבדה שנמצאת בדרך כלל במודלים של Machine Learning (לדוגמה, מתמטיקה המטריצה ​​המעורבת בקונבולציה ושכבות צפופות).

מצד שני, רוב הטלפונים הסלולריים המודרניים מכילים שבבים טובים יותר בטיפול בפעולות כבדות אלו. השימוש בהם לפעולות רשת עצביות מספק יתרונות עצומים במונחים של חביון ויעילות צריכת חשמל. לדוגמה, GPUs יכולים לספק מהירות של עד פי 5 בהשהיה , בעוד שה- Qualcomm® Hexagon DSP הראה כמפחית את צריכת החשמל של עד 75% בניסויים שלנו.

לכל אחד מהמאיצים הללו יש ממשקי API המאפשרים חישובים מותאמים אישית, כגון OpenCL או OpenGL ES עבור GPU נייד ו- Qualcomm® Hexagon SDK עבור DSP. בדרך כלל, תצטרך לכתוב הרבה קוד מותאם אישית כדי להפעיל רשת עצבית דרך ממשקים אלה. הדברים מסתבכים עוד יותר כאשר לוקחים בחשבון שלכל מאיץ יש את היתרונות והחסרונות שלו ואינו יכול לבצע כל פעולה ברשת עצבית. ה-API של Delegate של TensorFlow Lite פותר את הבעיה הזו בכך שהוא פועל כגשר בין זמן הריצה של TFLite לבין ממשקי ה-API ברמה נמוכה יותר.

זמן ריצה עם נציגים

בחירת נציג

TensorFlow Lite תומך במספר נציגים, שכל אחד מהם מותאם לפלטפורמות מסוימות ולסוגים מסוימים של דגמים. בדרך כלל, יהיו מספר נציגים הרלוונטיים למקרה השימוש שלך, בהתאם לשני קריטריונים עיקריים: הפלטפורמה (אנדרואיד או iOS?) שאליה אתה ממקד, וסוג הדגם (נקודה צפה או כמותית?) שאתה מנסה להאיץ .

נציגים לפי פלטפורמה

חוצה פלטפורמות (אנדרואיד ו-iOS)

  • נציג GPU - ניתן להשתמש בנציג GPU גם באנדרואיד וגם ב-iOS. הוא מותאם להרצת דגמים מבוססי 32 סיביות ו-16 סיביות עם GPU זמין. זה גם תומך בדגמים 8-bit quantized ומספק ביצועי GPU בקנה אחד עם גרסאות הציפה שלהם. לפרטים על נציג ה-GPU, ראה TensorFlow Lite ב-GPU . למדריכים שלב אחר שלב על שימוש ב-GPU Delegate עם אנדרואיד ו-iOS, ראה הדרכה של TensorFlow Lite GPU Delegate .

דְמוּי אָדָם

  • נציג NNAPI עבור מכשירי אנדרואיד חדשים יותר - ניתן להשתמש בנציג NNAPI כדי להאיץ דגמים במכשירי אנדרואיד עם GPU, DSP ו/או NPU זמין. הוא זמין באנדרואיד 8.1 (API 27+) ומעלה. לסקירה כללית של נציג NNAPI, הוראות שלב אחר שלב ושיטות עבודה מומלצות, ראה נציג TensorFlow Lite NNAPI .
  • נציג Hexagon עבור מכשירי אנדרואיד ישנים יותר - ניתן להשתמש בנציג Hexagon כדי להאיץ דגמים במכשירי אנדרואיד עם Qualcomm Hexagon DSP. ניתן להשתמש בו במכשירים המריצים גרסאות ישנות יותר של אנדרואיד שאינן תומכות ב-NNAPI. ראה נציג TensorFlow Lite Hexagon לפרטים נוספים.

iOS

  • Core ML delegate עבור מכשירי אייפון ואייפד חדשים יותר - עבור מכשירי אייפון ואייפד חדשים יותר שבהם Neural Engine זמין, אתה יכול להשתמש ב-Core ML delegate כדי להאיץ מסקנות עבור דגמי נקודה צפה של 32 סיביות או 16 סיביות. Neural Engine זמין מכשירים ניידים של Apple עם A12 SoC ומעלה. לסקירה כללית של נציג Core ML והוראות שלב אחר שלב, ראה TensorFlow Lite Core ML נציג .

נציגים לפי סוג דגם

כל מאיץ מתוכנן מתוך מחשבה על רוחב סיביות מסוים של נתונים. אם תספק מודל של נקודה צפה לנציג שתומך רק בפעולות קוונטיות של 8 סיביות (כגון ה- Hexagon delegate ), הוא ידחה את כל הפעולות שלו והמודל ירוץ כולו על ה-CPU. כדי למנוע הפתעות כאלה, הטבלה שלהלן מספקת סקירה כללית של תמיכת נציגים בהתבסס על סוג הדגם:

סוג דגם GPU NNAPI מְשׁוּשֶׁה CoreML
נקודה צפה (32 סיביות) כן כן לא כן
קוונטיזציה לצוף16 לאחר אימון כן לא לא כן
קוונטיזציה של טווח דינמי לאחר אימון כן כן לא לא
קוונטיזציה של מספרים שלמים לאחר אימון כן כן כן לא
הכשרה מודעת לקוונטיזציה כן כן כן לא

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

המידע בסעיף זה משמש כקו מנחה גס לרשימה קצרה של הנציגים שיכולים לשפר את הבקשה שלך. עם זאת, חשוב לציין שלכל נציג יש מערכת מוגדרת מראש של פעולות שבהן הוא תומך, ועשויה לבצע אחרת בהתאם לדגם ולמכשיר; לדוגמה, נציג NNAPI עשוי לבחור להשתמש ב-Edge-TPU של גוגל בטלפון Pixel תוך שימוש ב-DSP במכשיר אחר. לכן, בדרך כלל מומלץ לבצע מידה מסוימת כדי לאמוד עד כמה נציג מועיל לצרכים שלך. זה גם עוזר להצדיק את הגדלת הגודל הבינארי הקשורה לצירוף נציג לזמן הריצה של TensorFlow Lite.

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

כלים להערכה

חביון וטביעת זיכרון

ניתן להשתמש בכלי ה-benchmark של TensorFlow Lite עם פרמטרים מתאימים להערכת ביצועי המודל, כולל זמן השהייה ממוצעת, תקורה של אתחול, טביעת זיכרון וכו'. כלי זה תומך במספר דגלים כדי להבין את תצורת הנציגים הטובה ביותר עבור הדגם שלך. לדוגמה, --gpu_backend=gl ניתן לציין עם --use_gpu כדי למדוד ביצוע GPU עם OpenGL. הרשימה המלאה של פרמטרי נציג נתמכים מוגדרת בתיעוד המפורט .

להלן דוגמה להרצה עבור דגם כמותי עם GPU דרך adb :

adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/mobilenet_v1_224_quant.tflite \
  --use_gpu=true

אתה יכול להוריד גרסה בנויה מראש של הכלי הזה לאנדרואיד, ארכיטקטורת ARM של 64 סיביות כאן ( פרטים נוספים ).

דיוק ונכונות

נציגים בדרך כלל מבצעים חישובים בדיוק שונה מאשר עמיתיהם המעבדים. כתוצאה מכך, קיים חילופי דיוק (בדרך כלל מינורי) הקשורים לשימוש בנציג להאצת חומרה. שימו לב שזה לא תמיד נכון; לדוגמה, מכיוון שה-GPU משתמש בדיוק בנקודה צפה כדי להפעיל מודלים כמותיים, עשוי להיות שיפור דיוק קל (לדוגמה, שיפור של <1% Top-5 בסיווג תמונות ILSVRC).

ל-TensorFlow Lite יש שני סוגים של כלים למדידת מידת הדיוק של נציג מתנהג עבור מודל נתון: מבוסס- משימות ו- Task-Agnostic . כל הכלים המתוארים בסעיף זה תומכים בפרמטרי האצלה המתקדמים שבהם השתמש כלי ההשוואה מהסעיף הקודם. שים לב שתתי הסעיפים שלהלן מתמקדים בהערכת נציג (האם הנציג מבצע אותו דבר כמו המעבד?) ולא בהערכת מודל (האם המודל עצמו טוב למשימה?).

הערכה מבוססת משימות

ל-TensorFlow Lite יש כלים להערכת נכונות בשתי משימות מבוססות תמונה:

ניתן למצוא כאן קבצים בינאריים שנבנו מראש של כלים אלה (אנדרואיד, ארכיטקטורת ARM של 64 סיביות), יחד עם תיעוד:

הדוגמה שלהלן מדגימה הערכת סיווג תמונה עם NNAPI תוך שימוש ב-Edge-TPU של גוגל ב-Pixel 4:

adb shell /data/local/tmp/run_eval \
  --model_file=/data/local/tmp/mobilenet_quant_v1_224.tflite \
  --ground_truth_images_path=/data/local/tmp/ilsvrc_images \
  --ground_truth_labels=/data/local/tmp/ilsvrc_validation_labels.txt \
  --model_output_labels=/data/local/tmp/model_output_labels.txt \
  --output_file_path=/data/local/tmp/accuracy_output.txt \
  --num_images=0 # Run on all images. \
  --use_nnapi=true \
  --nnapi_accelerator_name=google-edgetpu

הפלט הצפוי הוא רשימה של מדדי Top-K מ-1 עד 10:

Top-1 Accuracy: 0.733333
Top-2 Accuracy: 0.826667
Top-3 Accuracy: 0.856667
Top-4 Accuracy: 0.87
Top-5 Accuracy: 0.89
Top-6 Accuracy: 0.903333
Top-7 Accuracy: 0.906667
Top-8 Accuracy: 0.913333
Top-9 Accuracy: 0.92
Top-10 Accuracy: 0.923333

הערכה אגנוסטית למשימה

עבור משימות שבהן אין כלי הערכה מבוסס במכשיר, או אם אתה מתנסה במודלים מותאמים אישית, ל-TensorFlow Lite יש את הכלי Inference Diff . (אנדרואיד, ארכיטקטורה בינארית של ARM 64 סיביות כאן )

Inference Diff משווה את ביצוע TensorFlow Lite (במונחים של חביון וסטיית ערך פלט) בשתי הגדרות:

  • מסקנות CPU עם חוט יחיד
  • מסקנות מוגדרות על ידי משתמש - מוגדרות על ידי פרמטרים אלו

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

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

עבור דגם עם טנזור פלט יחיד, הפלט עשוי להיראות כך:

Num evaluation runs: 50
Reference run latency: avg=84364.2(us), std_dev=12525(us)
Test run latency: avg=7281.64(us), std_dev=2089(us)
OutputDiff[0]: avg_error=1.96277e-05, std_dev=6.95767e-06

המשמעות היא שעבור טנזור הפלט באינדקס 0 , האלמנטים מפלט המעבד שונים מפלט הנציג בממוצע של 1.96e-05 .

שימו לב שפירוש המספרים הללו דורש ידע מעמיק יותר של המודל, ומה מסמל כל טנזור פלט. אם זו רגרסיה פשוטה שקובעת איזשהו ניקוד או הטבעה, ההפרש צריך להיות נמוך (אחרת זו שגיאה עם הנציג). עם זאת, יציאות כמו 'מחלקת זיהוי' מדגמי SSD קצת יותר קשה לפרש. לדוגמה, זה עשוי להראות הבדל באמצעות הכלי הזה, אבל זה אולי לא אומר שמשהו ממש לא בסדר עם הנציג: שקול שני מחלקות (מזויפות): "טלוויזיה (מזהה: 10)", "צג (מזהה:20)" - אם נציג קצת מחוץ לאמת הזהב ומציג מוניטור במקום טלוויזיה, הפרש הפלט של הטנזור הזה עשוי להיות משהו כמו 20-10 = 10.