Google I/O הוא עטיפה! התעדכן בהפעלות של TensorFlow. צפה בהפעלות

אופטימיזציה של ביצועי TensorFlow באמצעות Profiler

מדריך זה מדגים כיצד להשתמש בכלים הזמינים עם TensorFlow Profiler כדי לעקוב אחר הביצועים של דגמי TensorFlow שלך. תלמד כיצד להבין כיצד המודל שלך מתפקד במארח (CPU), במכשיר (GPU), או בשילוב של המארח והמכשיר(ים).

יצירת פרופילים עוזרת להבין את צריכת משאבי החומרה (זמן וזיכרון) של פעולות TensorFlow השונות (ops) במודל שלך ולפתור צווארי בקבוק בביצועים ובסופו של דבר לגרום למודל לפעול מהר יותר.

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

אם אתה רוצה פרופיל ביצועי המודל שלך על ענן TPUs, עיין במדריך הענן TPU .

התקן את התנאים המוקדמים של Profiler ו-GPU

התקן את הפלאגין Profiler עבור TensorBoard עם pip. שימו לב שהפרופיל דורש את הגירסאות העדכניות ביותר של TensorFlow ו-TensorBoard (>=2.2).

pip install -U tensorboard_plugin_profile

כדי ליצור פרופיל ב-GPU, עליך:

  1. פגוש את הנהגים GPU NVIDIA® ודרישות Toolkit CUDA® הנסחרות דרישות תוכנה תמיכה TensorFlow GPU .

  2. ודאו כלי פרופיל NVIDIA® CUDA® הממשק (CUPTI) מקיימים על הנתיב:

    /sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
grep libcupti

אם אתה לא צריך CUPTI על השביל, שיתווסף ספריית ההתקנה שלה $LD_LIBRARY_PATH משתנה הסביבה על ידי הפעלה:

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

ואז, להפעיל את ldconfig הפקודה הנ"ל שוב כדי לוודא כי הספרייה CUPTI נמצא.

פתרון בעיות הרשאות

כשמפעילים פרופילים עם Toolkit CUDA® בסביבה דוקר או על לינוקס, אתה עלול להיתקל בבעיות הקשורות הרשאות CUPTI מספיקות ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). עבור אל Docs Developer NVIDIA כדי ללמוד עוד על איך אתה יכול לפתור בעיות אלה על לינוקס.

כדי לפתור בעיות הרשאות CUPTI בסביבת Docker, הפעל

docker run option '--privileged=true'

כלים לפרופילים

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

ל-Profiler יש מבחר של כלים שיעזרו בניתוח ביצועים:

  • דף סקירה כללית
  • מנתח צינור קלט
  • סטטיסטיקות TensorFlow
  • Trace Viewer
  • נתונים סטטיסטיים של ליבת GPU
  • כלי פרופיל זיכרון
  • Pod Viewer

דף סקירה כללית

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

דף הסקירה מציג נתונים באופן הבא:

תמונה

  • סיכום ביצועים: הצגת סיכום ברמה גבוהה של ביצועי המודל שלך. סיכום הביצועים כולל שני חלקים:

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

      • קומפילציה: הזמן המושקע בקומפילציה של גרעינים.
      • קלט: הזמן המושקע בקריאת נתוני קלט.
      • פלט: הזמן המושקע בקריאת נתוני הפלט.
      • השקת ליבה: זמן השקת המארח להפעלת גרעינים
      • זמן חישוב מארח..
      • זמן תקשורת בין מכשיר למכשיר.
      • זמן חישוב במכשיר.
      • כל השאר, כולל Python תקורה.

    2. דיוק מחשוב במכשיר - מדווח על אחוז זמן החישוב של המכשיר המשתמש בחישובים של 16 ו-32 סיביות.

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

  • Top 10 פעולות TensorFlow במכשיר (למשל GPU): מציג את ops על-מכשיר רץ הכי הרבה זמן.

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

  • הפעלת סביבה: מציג סיכום ברמה גבוהה של סביבת ריצת המודל כוללת:

    • מספר המארחים בשימוש.
    • סוג מכשיר (GPU/TPU).
    • מספר ליבות המכשיר.

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

מנתח צינור קלט

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

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

  1. קריאת קובץ.
  2. עיבוד מקדים של קבצים (אופציונלי).
  3. העברת קבצים מהמארח למכשיר.

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

מנתח צינור הקלט אומר לך מיד אם התוכנית שלך קשורה לקלט ומנחה אותך דרך ניתוח צד המכשיר והמארח כדי לאתר באגים בצווארי בקבוק בכל שלב בצינור הקלט.

עיין בהנחיות לגבי ביצועי צינור קלט לקבלת שיטות מומלצות מומלצות למיטוב צינורות קלט הנתונים שלך.

לוח מחוונים של צינור קלט

לפתיחת מנתח צינור ההזנה, בחר פרופיל, ולאחר מכן בחר input_pipeline_analyzer מתוך התפריט הנפתח כלים.

תמונה

לוח המחוונים מכיל שלושה חלקים:

  1. סיכום: מסכם את צינור הזנה הכולל מידע על אם היישום שלך הוא כבול קלט, ואם כן, בכמה.
  2. ניתוח ההתקנים בצד: מציג המפורטים, תוצאות הניתוח בצד המכשיר, כולל הצעד פעמי למכשיר ואת טווח הזמן שבו המכשיר בילה מחכה נתוני הקלט ברחבי ליבות בכל שלב.
  3. ניתוח Host-לוואי: מופעי ניתוח מפורט בצד המארח, כולל פירוט של זמן עיבוד קלט במחשב המארח.

סיכום צינור קלט

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

ניתוח צד המכשיר

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

  1. זמן שלב זממו נגד מספר שלבים: מציג גרף של זמן התקן צעד (באלפיות שנייה) מעל כל השלבים שנדגמו. כל שלב מחולק לקטגוריות מרובות (עם צבעים שונים) של המקום שבו הזמן מבלה. האזור האדום מתאים לחלק מזמן הצעד שבו המכשירים ישבו בטל והמתינו לנתוני קלט מהמארח. האזור הירוק מראה כמה מהזמן המכשיר פעל בפועל.
  2. נתונים סטטיסטיים בזמן שלב: דוחות סטיית הממוצע, התקן, וטווח ([מינימום, מקסימום]) של זמן צעד התקן.

ניתוח צד המארח

הניתוח המארח בצד מדווח פירוט של זמן עיבוד קלט (הזמן המושקע על tf.data ops API) במארח למספר קטגוריות:

  • קריאת נתונים מקבצים על פי דרישה: זמן בילה על קריאת נתונים מקבצים בלי במטמון, הכנה מקדימה, ו interleaving.
  • קריאת נתונים מקבצים מראש: הזמן בילה בקריאת קבצים, כולל במטמון, הכנה מקדימה, ו interleaving.
  • נתונים עיבוד מקדים: זמן בילה על ops עיבוד מקדים, כגון שחרור לחץ לתמונה.
  • נתונים Enqueuing שיועברו למכשיר: זמן בילה לשים נתונים לתוך תור infeed לפני העברת נתונים למכשיר.

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

תמונה

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

  1. אופ קלט: מראה את שם אופ TensorFlow של op קלט.
  2. מילים: מציג את המספר הכולל של מקרים של הוצאה להורג אופ בתקופת פרופיל.
  3. זמן כולל (ms): מציג את הסכום המצטבר של משך זמן על כל המקרים האלה.
  4. סה"כ זמן%: מציג את הזמן הכולל שהוצא על מאמר דעה כשבר של הזמן הכולל של הביקור בעיבוד קלט.
  5. סה"כ עצמי זמן (ב- ms): מציג את הסכום המצטבר של הזמן העצמי שמוקדש בכל המקרים האלה. הזמן העצמי כאן מודד את הזמן המושקע בתוך גוף הפונקציה, לא כולל את הזמן המושקע בפונקציה שהוא קורא.
  6. סה"כ עצמי זמן%. מציג את הזמן העצמי הכולל כשבריר מהזמן הכולל שהושקע בעיבוד קלט.
  7. קטגוריה. מציג את קטגוריית העיבוד של הקלט op.

נתונים סטטיסטיים של TensorFlow

הכלי TensorFlow Stats מציג את הביצועים של כל TensorFlow מבצע (op) שמתבצע במארח או במכשיר במהלך הפעלת פרופילים.

תמונה

הכלי מציג מידע על ביצועים בשתי חלוניות:

  • החלונית העליונה מציגה עד ארבעה תרשימי עוגה:

    1. חלוקת זמן הביצוע העצמי של כל פעולה על המארח.
    2. חלוקת זמן הביצוע העצמי של כל סוג פעולה על המארח.
    3. חלוקת זמן הביצוע העצמי של כל פעולה במכשיר.
    4. התפלגות זמן הביצוע העצמי של כל סוג פעולה במכשיר.

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

    ציין זאת:

    • אם למבצעים מסוימים יש אופציות ילדים:

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

    • אם פועל על המארח:

      • האחוז מסך הזמן העצמי במכשיר שנגרם על ידי ההפעלה יהיה 0.
      • האחוז המצטבר מהזמן העצמי הכולל במכשיר עד וכולל פעולה זו יהיה 0.

    • אם מבצעים פעולה במכשיר:

      • האחוז מסך הזמן העצמי על המארח שייגרם על ידי מבצע זה יהיה 0.
      • האחוז המצטבר של הזמן העצמי הכולל במארח עד וכולל פעולה זו יהיה 0.

אתה יכול לבחור לכלול או לא לכלול זמן סרק בתרשימים ובטבלה.

צופה עקבות

מציג המעקב מציג ציר זמן המציג:

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

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

מעקב אחר ממשק הצופה

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

תמונה

מסך זה מכיל את המרכיבים העיקריים הבאים:

  1. בחלונית Timeline: מופעים ops כי המכשיר המארח להורג לאורך זמן.
  2. בחלונית פרטים: מידע נוסף מופעים עבור ops הנבחר בחלונית Timeline.

חלונית ציר הזמן מכילה את הרכיבים הבאים:

  1. בסרגל העליון: מכיל פקדים עזר שונים.
  2. ציר זמן: מופעי זמן ביחס לתחילת העקבות.
  3. סעיף ותוויות המסלול: כל קטע מכיל מספר רב של מסלולים ויש לו משולש מצד שמאל שאתה יכול ללחוץ כדי להרחיב ולכווץ את הקטע. יש סעיף אחד לכל רכיב עיבוד במערכת.
  4. בורר כלי: מכיל כלים שונים עבור אינטראקציה עם הצופה עקבות כגון זום, פאן, בחר, ותזמון. השתמש בכלי התזמון כדי לסמן מרווח זמן.
  5. אירועים: אלה מראים את הזמן שבמהלכו אופ הוצא להורג או את המשך-אירועים מטא, כגון צעדי אימונים.
קטעים ומסלולים

מציג המעקבים מכיל את הסעיפים הבאים:

  • סעיף אחת עבור כל צומת התקן, שכותרתו עם מספר השבב למכשיר ואת הצומת המכשיר בתוך שבב (למשל, /device:GPU:0 (pid 0) ). כל קטע של צומת מכשיר מכיל את הרצועות הבאות:
    • שלב: מציג את משך הצעדים הכשרים שפעלו על המכשיר
    • Ops TensorFlow: מראה את ops להורג על המכשיר
    • Ops XLA: מופעים XLA פעולות (ops) רץ על המכשיר אם XLA הוא המהדר בשימוש (כל אופ TensorFlow מתורגם ops XLA אחד או מספר למהדר XLA מתרגמת את ops XLA לקוד שרץ על המכשיר.).
  • מדור אחד הנושאים לרוץ על המעבד של המחשב המארח, שכותרתו "חוטים Host". הקטע מכיל רצועה אחת עבור כל פתיל CPU. שים לב שאתה יכול להתעלם מהמידע המוצג לצד תוויות הסעיפים.
אירועים

אירועים בתוך ציר הזמן מוצגים בצבעים שונים; לצבעים עצמם אין משמעות ספציפית.

מציג המעקבים יכול גם להציג עקבות של קריאות לפונקציות Python בתוכנית TensorFlow שלך. אם אתה משתמש tf.profiler.experimental.start API, אתה יכול לאפשר Python התחקות על ידי שימוש ProfilerOptions namedtuple כאשר מתחיל יצירת פרופיל. לחלופין, אם אתה משתמש במצב הדגימה לאפיון, אתה יכול לבחור את רמת התחקות על ידי שימוש באפשרויות הנפתחת ב השיח בפרופיל הלכיד.

תמונה

נתונים סטטיסטיים של ליבת GPU

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

תמונה

הכלי מציג מידע בשתי חלוניות:

  • החלונית העליונה מציגה תרשים עוגה המציג את גרעיני ה-CUDA בעלי הזמן הכולל הגבוה ביותר שחלף.

  • החלונית התחתונה מציגה טבלה עם הנתונים הבאים עבור כל זוג קרנל-op ייחודי:

    • דירוג בסדר יורד של משך ה-GPU הכולל שחלף, מקובץ לפי זוג קרנל-op.
    • שם הקרנל שהושק.
    • מספר אוגרי GPU בשימוש על ידי הליבה.
    • הגודל הכולל של זיכרון משותף (סטטי + דינמי משותף) בשימוש בבתים.
    • ממד הבלוק מבוטא blockDim.x, blockDim.y, blockDim.z .
    • מידות הרשת מבוטאות gridDim.x, gridDim.y, gridDim.z .
    • בין אם op כשיר לשימוש ליבות מותחות .
    • האם הקרנל מכיל הוראות Tensor Core.
    • שם האופציה שהשיקה את הגרעין הזה.
    • מספר המופעים של זוג קרנל-op זה.
    • הזמן הכולל שחלף ב-GPU במיקרו-שניות.
    • זמן ה-GPU הממוצע שחלף במיקרו-שניות.
    • זמן ה-GPU המינימלי שחלף במיקרו-שניות.
    • זמן ה-GPU המקסימלי שחלף במיקרו-שניות.

כלי פרופיל זיכרון

מפקח הכלי בפרופיל זיכרון השימוש בזיכרון של המכשיר במהלך הפסקת הפרופיל. אתה יכול להשתמש בכלי זה כדי:

  • נפה באגים בבעיות מחוץ לזיכרון (OOM) על ידי איתור שיא השימוש בזיכרון והקצאת הזיכרון המתאימה למבצעי TensorFlow. ניתן גם באגים בעיות Oom שעלולות להתעורר כאשר אתה מפעיל ריבוי משתמשים היקש.
  • ניפוי באגים של פיצול זיכרון.

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

  1. סיכום פרופיל זיכרון
  2. זיכרון ציר זמן גרף
  3. טבלת פירוט זיכרון

סיכום פרופיל הזיכרון

סעיף זה מציג סיכום ברמה גבוהה של פרופיל הזיכרון של תוכנית TensorFlow שלך כפי שמוצג להלן:

לסיכום פרופיל הזיכרון יש שישה שדות:

  1. מזהה זיכרון: נפתחת אשר מפרט את כל מערכות זיכרון המכשיר זמין. בחר את מערכת הזיכרון שברצונך להציג מהתפריט הנפתח.
  2. #Allocation: מספר הקצאות זיכרון שבוצעו במהלך מרווח הפרופיל.
  3. #Deallocation: מספר deallocations זיכרון בקטע פרופילים
  4. קיבולת זיכרון: הקיבולת הכוללת (ב gibs) של מערכת הזיכרון שבחרת.
  5. שיא בצריכת החשמל היפ: השימוש בזיכרון השיא (ב gibs) מאז המודל התחיל לרוץ.
  6. שימוש בזיכרון שיא: השימוש בזיכרון השיא (ב gibs) במרווח פרופיל. שדה זה מכיל את שדות המשנה הבאים:
    1. חותם זמן: חותמת הזמן של מועד את השימוש בזיכרון השיא התרחש על גרף ציר הזמן.
    2. הזמנת סטאק: כמות זיכרון שמור על הערימה (ב gibs).
    3. הקצאת היפ: כמות הזיכרון מוקצה על הערימה (ב gibs).
    4. חינם זיכרון: כמות זיכרון פנוי (ב gibs). קיבולת הזיכרון היא הסכום הכולל של שמירת המחסנית, הקצאת הערימה והזיכרון הפנוי.
    5. פיצול: אחוז הפיצול (נמוך עדיף). זה מחושב כאחוז (1 - Size of the largest chunk of free memory / Total free memory) .

גרף ציר זמן זיכרון

סעיף זה מציג עלילה של השימוש בזיכרון (ב-GiBs) ואחוז הפיצול מול זמן (ב-ms).

תמונה

ציר ה-X מייצג את ציר הזמן (ב-ms) של מרווח הפרופיל. ציר ה-Y משמאל מייצג את השימוש בזיכרון (ב-GiBs) וציר ה-Y מימין מייצג את אחוז הפיצול. בכל נקודת זמן על ציר ה-X, הזיכרון הכולל מתחלק לשלוש קטגוריות: מחסנית (באדום), ערימה (בכתום) וחופשית (בירוק). העבר את העכבר מעל חותמת זמן ספציפית כדי להציג את הפרטים על אירועי הקצאת/ביטול ההקצאה של זיכרון באותה נקודה כמו להלן:

תמונה

החלון המוקפץ מציג את המידע הבא:

  • חותמת (ms): מיקומו של האירוע שנבחר על ציר הזמן.
  • אירוע: סוג האירוע (הקצאה או deallocation).
  • requested_size (gibs): כמות הזיכרון מבוקשת. זה יהיה מספר שלילי עבור אירועי ביטול ההקצאה.
  • allocation_size (gibs): הסכום בפועל של זיכרון שהוקצה. זה יהיה מספר שלילי עבור אירועי ביטול ההקצאה.
  • tf_op: אופ TensorFlow כי בקשות להקצאה / deallocation.
  • step_id: צעד האימונים שבה אירוע זה התרחש.
  • REGION_TYPE: סוג ישות נתון בזיכרון המוקצה הזה מיועד. ערכים אפשריים הם temp עבור temporaries, output עבור הפעלות והדרגות, וכן persist / dynamic עבור משקולות וקבוע.
  • DATA_TYPE: סוג האלמנט המותח (למשל, uint8 עבור שלם 8 סיבי חתום).
  • tensor_shape: הצורה מותח להיות מוקצה / deallocated.
  • memory_in_use (gibs): זיכרון הכולל שנמצא בשימוש בשלב זה של הזמן.

טבלת פירוט זיכרון

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

תמונה

יש שורה אחת לכל TensorFlow Op ולכל שורה יש את העמודות הבאות:

  • אופ שם: השם של op TensorFlow.
  • גודל הקצאה (gibs): הסכום הכולל של זיכרון שהוקצה op זה.
  • גודל מבוקש (gibs): הסכום הכולל של זיכרון המבוקש עבור op זה.
  • מופעים: מספר הקצאות op זה.
  • סוג אזור: סוג ישות נתונים שזיכרון זה מוקצה הוא. ערכים אפשריים הם temp עבור temporaries, output עבור הפעלות והדרגות, וכן persist / dynamic עבור משקולות וקבוע.
  • סוג נתונים: סוג האלמנט המותח.
  • Shape: הצורה של טנזורים המוקצה.

מציג פוד

הכלי Pod Viewer מציג את פירוט שלב ההדרכה על פני כל העובדים.

תמונה

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

ניתוח צוואר בקבוק של tf.data

tf.data כלי ניתוח צוואר הבקבוק מזהים אוטומטית צווארי בקבוק tf.data צינורות הזנה בתכנית שלך ומספקים המלצות על איך לתקן אותם. זה עובד עם כל תוכנית באמצעות tf.data קשר לפלטפורמה (CPU / GPU / TPU). הניתוח וההמלצות שלה מבוססים על זה מדריך .

הוא מזהה צוואר בקבוק על ידי ביצוע השלבים הבאים:

  1. מצא את המארח הכי קשור לקלט.
  2. מצא הביצוע האיטי ביותר של tf.data צינור הזנה.
  3. שחזר את גרף צינור הקלט ממעקב הפרופיל.
  4. מצא את הנתיב הקריטי בגרף צינור הקלט.
  5. זהה את הטרנספורמציה האיטית ביותר בנתיב הקריטי כצוואר בקבוק.

ממשק המשתמש מחולק לשלושה חלקים: סיכום ניתוח ביצועים, סיכום של כל קלט צינורות קלט צינור גרף.

סיכום ניתוח ביצועים

תמונה

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

כיצד לקרוא את השם הארוך של tf.data iterator

שם ארוך מעוצב כמו Iterator::<Dataset_1>::...::<Dataset_n> . בשם רב, <Dataset_n> שמתאים לסוג iterator ואת מערכי נתונים אחרים בשם ארוך מייצגים טרנספורמציות במורד הזרם.

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

dataset = tf.data.Dataset.range(10).map(lambda x: x).repeat(2).batch(5)

השמות הארוכים של האיטרטורים ממערך הנתונים שלמעלה יהיו:

סוג איטרטור שם ארוך
טווח איטרטור::אצווה::חזרה::מפה::טווח
מַפָּה Iterator::אצווה::Repeat::Map
חזור איטרטור::אצווה::חזור
קבוצה Iterator::אצווה

סיכום כל צינורות הקלט

תמונה

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

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

גרף צינור קלט

תמונה

סעיף זה מציג את גרף צינור הקלט עם מידע זמן הביצוע. אתה יכול להשתמש ב-"Host" ו-"Input Pipeline" כדי לבחור איזה מארח וצינור קלט לראות. הוצאות להורג של צינור הזנה מסודרים על ידי זמן הביצוע בסדר יורד שבו אתה יכול לבחור בעזרת התפריט הנפתח דרגה.

תמונה

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

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

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

Self זמן הוא סה"כ זמן ללא זמן חפף עם בלוטות הילד מיידיות.

"# שיחות" הוא מספר הפעמים שצינור הקלט מבוצע.

איסוף נתוני ביצועים

TensorFlow Profiler אוסף פעילויות מארח ועקבות GPU של דגם TensorFlow שלך. אתה יכול להגדיר את Profiler לאסוף נתוני ביצועים דרך המצב התוכנותי או מצב הדגימה.

ממשקי API ליצירת פרופילים

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

  • מצב תוכניתית באמצעות Callback TensorBoard Keras ( tf.keras.callbacks.TensorBoard )

    # Profile from batches 10 to 15
tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                             profile_batch='10, 15')

# Train the model and use the TensorBoard Keras callback to collect
# performance profiling data
model.fit(train_data,
          steps_per_epoch=20,
          epochs=5,
          callbacks=[tb_callback])

  • מצב תוכניתית באמצעות tf.profiler API פונקציה

    tf.profiler.experimental.start('logdir')
# Train the model here
tf.profiler.experimental.stop()

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

    with tf.profiler.experimental.Profile('logdir'):
    # Train the model here
    pass

  • דגימת מצב: בצע על פי דרישת פרופילים באמצעות tf.profiler.experimental.server.start להתחיל בשרת gRPC עם ריצת דגם TensorFlow שלך. לאחר הפעלת שרת gRPC והפעלת המודל שלך, אתה יכול ללכוד פרופיל דרך הכפתור בפרופיל הלכיד ב plugin פרופיל TensorBoard. השתמש בסקריפט בסעיף התקנת פרופיל למעלה כדי להפעיל מופע TensorBoard אם הוא עדיין לא פועל.

    לדוגמא,

    # Start a profiler server before your model runs.
tf.profiler.experimental.server.start(6009)
# (Model code goes here).
#  Send a request to the profiler server to collect a trace of your model.
tf.profiler.experimental.client.trace('grpc://localhost:6009',
                                      'gs://your_tb_logdir', 2000)

    דוגמה ליצירת פרופיל של מספר עובדים:

    # E.g. your worker IP addresses are 10.0.0.2, 10.0.0.3, 10.0.0.4, and you
# would like to profile for a duration of 2 seconds.
tf.profiler.experimental.client.trace(
    'grpc://10.0.0.2:8466,grpc://10.0.0.3:8466,grpc://10.0.0.4:8466',
    'gs://your_tb_logdir',
    2000)

השתמש שיח בפרופיל הלכיד לציין:

  • רשימה מופרדת בפסיקים של כתובות URL של שירותי פרופיל או שמות TPU.
  • משך פרופיל.
  • רמת מעקב אחר שיחות מכשיר, מארח ופונקציית Python.
  • כמה פעמים אתה רוצה ש-Profiler ינסה שוב ללכוד פרופילים אם לא יצליח בהתחלה.

יצירת פרופילים של לולאות אימון מותאמות אישית

לפרופיל לולאות אימון מותאם אישית בקוד TensorFlow שלך, מכשיר הלולאה אימונים עם tf.profiler.experimental.Trace API כדי לסמן את גבולות צעד עבור Profiler.

name הטיעון משמש כקידומת עבור שמות הצעד, את step_num טיעון המילה מצורף בשמות הצעד, ואת _r טיעון המילה עושה אירוע העקבות הזה עובר עיבוד כאירוע צעד ידי Profiler.

לדוגמא,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

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

ודא כי אתה כולל את iterator הנתונים בתוך tf.profiler.experimental.Trace בהקשר לניתוח מדויק של צינור הזנה.

קטע הקוד שלהלן הוא אנטי דפוס:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

מקרי שימוש בפרופיל

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

  • לעומת מקומי מרחוק פרופיל: אלו הם שתי דרכים נפוצות של הקמת סביבת הפרופיל שלך. ביצירת פרופיל מקומי, ממשק ה-API של הפרופיל נקרא באותו מכונה שהדגם שלך מפעיל, למשל, תחנת עבודה מקומית עם GPUs. ביצירת פרופילים מרחוק, ממשק ה-API לפרופילים נקרא במכונה אחרת מהמקום שבו המודל שלך מבצע, למשל, ב-Cloud TPU.
  • בניית פרופיל עובדים רבים: ניתן פרופיל מכונות מרובות בעת השימוש ביכולות אימון המופצת של TensorFlow.
  • פלטפורמת חומרה: מעבד בפרופיל, GPUs, ו TPUs.

הטבלה שלהלן מספקת סקירה מהירה של מקרי השימוש הנתמכים ב-TensorFlow שהוזכרו לעיל:

API לפרופילים מְקוֹמִי מְרוּחָק מספר עובדים פלטפורמות חומרה
TensorBoard Keras Callback נתמך אינו נתמך אינו נתמך מעבד, GPU
tf.profiler.experimental Start / Stop API נתמך אינו נתמך אינו נתמך מעבד, GPU
tf.profiler.experimental client.trace API נתמך נתמך נתמך מעבד, GPU, TPU
ממשק API של מנהל הקשר נתמך אינו נתמך אינו נתמך מעבד, GPU

שיטות עבודה מומלצות לביצועי מודל מיטביים

השתמש בהמלצות הבאות בהתאם לדגמי TensorFlow שלך כדי להשיג ביצועים מיטביים.

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

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

השתמש בנתונים מה-[#input_pipeline_analyzer] כדי לייעל את צינור קלט הנתונים שלך. צינור קלט נתונים יעיל יכול לשפר באופן דרסטי את מהירות ביצוע המודל שלך על ידי הפחתת זמן סרק המכשיר. נסו לשלב את שיטות העבודה המומלצות המפורטות ביצועים טובים יותר עם ה- API tf.data מדריך ומתחת לעשות צינור הזנה הנתונים שלך יעיל יותר.

  • באופן כללי, הקבילה של כל פעולות שאין צורך לבצע ברצף יכולה לייעל באופן משמעותי את צינור קלט הנתונים.

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

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

  • השתמש tf.data.Dataset.shard להכשרה רב GPU. הקפד לרסיס מוקדם מאוד בלולאת הקלט כדי למנוע הפחתה בתפוקה. כשאתה עובד עם TFRecords, ודא שאתה מפציץ את רשימת ה-TFRecords ולא את התוכן של TFRecords.

  • טען במקביל בכמה ops ידי קביעת הערך הדינמי של num_parallel_calls באמצעות tf.data.AUTOTUNE .

  • שקול להגביל את השימוש של tf.data.Dataset.from_generator כפי שהוא איטי יותר בהשוואה ops TensorFlow טהור.

  • שקול להגביל את השימוש של tf.py_function כפי שהוא לא יכול להיות בהמשכים ואינה נתמכת לרוץ TensorFlow מופץ.

  • השתמש tf.data.Options לשלוט אופטימיזציות סטטי צינור הזנה.

כמו כן קרא את tf.data ניתוח ביצועי המדריך לקבלת הנחיות נוספות על אופטימיזציה צינור ההזנה שלך.

בצע אופטימיזציה של הגדלת נתונים

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

השתמש ב-NVIDIA® DALI

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

אם אתה משתמש NVIDIA® GPUs עבור ראייה ממוחשבת ויישומים למידה עמוקים אודיו, שקול להשתמש בטעינת נתון הספרייה ( DALI ) כדי להאיץ את צינור הנתונים.

בדוק את NVIDIA® DALI: תפעול בתיעוד רשימת ops DALI נתמך.

השתמש בהברגה ובביצוע מקביל

Ops לרוץ על הנושאים CPU מרובים עם tf.config.threading API לבצע אותם מהר.

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

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

אם יש לך ops עצמאית חסימת אי (ops ללא נתיב ביים ביניהם על הגרף), שימוש tf.config.threading.set_inter_op_parallelism_threads להריץ אותם במקביל להשתמש בבריכה חוט זמין.

שונות

כאשר עובדים עם מודלים קטנים על GPUs NVIDIA®, אתה יכול להגדיר tf.compat.v1.ConfigProto.force_gpu_compatible=True לכפות כל tensors CPU שיוקצו עם זיכרון CUDA מוצמד לתת דחיפה משמעותית בביצועים מודל. עם זאת, היזהר בעת השימוש באפשרות זו עבור דגמים לא ידועים/גדולים מאוד מכיוון שהדבר עלול להשפיע לרעה על ביצועי המארח (CPU).

שפר את ביצועי המכשיר

בצע את שיטות העבודה המומלצות המפורטות כאן וגם מדריך מיטוב ביצועי GPU לבצע אופטימיזציה על-מכשיר ביצועי מודל TensorFlow.

אם אתה משתמש ב-NVIDIA GPUs, רישום את ה-GPU ואת ניצול הזיכרון לקובץ CSV על ידי הפעלת:

nvidia-smi
--query-gpu=utilization.gpu,utilization.memory,memory.total,
memory.free,memory.used --format=csv

הגדר פריסת נתונים

כאשר עובדים עם נתונים המכילים מידע על ערוצים (כמו תמונות), בצע אופטימיזציה של פורמט פריסת הנתונים כדי להעדיף את הערוצים האחרונים (NHWC על פני NCHW).

ערוץ-אחרוני פורמטי נתונים לשפר מותח Core ניצול ולספק שיפורי ביצועים משמעותיים במיוחד מודלי קונבולוציה כאשר מצמידים עם AMP. ניתן עדיין להפעיל פריסות נתונים של NCHW על ידי Tensor Cores, אך מציגים תקורה נוספת עקב פעולות טרנספוזיציה אוטומטיות.

אתה יכול לייעל את פריסת הנתונים להעדיף פריסות NHWC ידי הגדרת data_format="channels_last" עבור שכבות כגון tf.keras.layers.Conv2D , tf.keras.layers.Conv3D , ו tf.keras.layers.RandomRotation .

השתמש tf.keras.backend.set_image_data_format להגדיר את פורמט פריסת נתוני ברירת מחדל עבור ה- API backend Keras.

למקסם את המטמון L2

When working with NVIDIA® GPUs, execute the code snippet below before the training loop to max out the L2 fetch granularity to 128 bytes.

import ctypes

_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
# cudaLimitMaxL2FetchGranularity = 0x05
pValue = ctypes.cast((ctypes.c_int*1)(), ctypes.POINTER(ctypes.c_int))
_libcudart.cudaDeviceSetLimit(ctypes.c_int(0x05), ctypes.c_int(128))
_libcudart.cudaDeviceGetLimit(pValue, ctypes.c_int(0x05))
assert pValue.contents.value == 128

Configure GPU thread usage

The GPU thread mode decides how GPU threads are used.

Set the thread mode to gpu_private to make sure that preprocessing does not steal all the GPU threads. This will reduce the kernel launch delay during training. You can also set the number of threads per GPU. Set these values using environment variables.

import os

os.environ['TF_GPU_THREAD_MODE']='gpu_private'
os.environ['TF_GPU_THREAD_COUNT']='1'

Configure GPU memory options

In general, increase the batch size and scale the model to better utilize GPUs and get higher throughput. Note that increasing the batch size will change the model's accuracy so the model needs to be scaled by tuning hyperparameters like the learning rate to meet the target accuracy.

Also, use tf.config.experimental.set_memory_growth to allow GPU memory to grow to prevent all the available memory from being fully allocated to ops that require only a fraction of the memory. This allows other processes which consume GPU memory to run on the same device.

To learn more, check out the Limiting GPU memory growth guidance in the GPU guide to learn more.

Miscellaneous

  • Increase the training mini-batch size (number of training samples used per device in one iteration of the training loop) to the maximum amount that fits without an out of memory (OOM) error on the GPU. Increasing the batch size impacts the model's accuracy—so make sure you scale the model by tuning hyperparameters to meet the target accuracy.

  • Disable reporting OOM errors during tensor allocation in production code. Set report_tensor_allocations_upon_oom=False in tf.compat.v1.RunOptions .

  • For models with convolution layers, remove bias addition if using batch normalization. Batch normalization shifts values by their mean and this removes the need to have a constant bias term.

  • Use TF Stats to find out how efficiently on-device ops run.

  • Use tf.function to perform computations and optionally, enable the jit_compile=True flag ( tf.function(jit_compile=True ). To learn more, go to Use XLA tf.function .

  • Minimize host Python operations between steps and reduce callbacks. Calculate metrics every few steps instead of at every step.

  • Keep the device compute units busy.

  • Send data to multiple devices in parallel.

  • Consider using 16-bit numerical representations , such as fp16 —the half-precision floating point format specified by IEEE—or the Brain floating-point bfloat16 format.

Additional resources

Known limitations

Profiling multiple GPUs on TensorFlow 2.2 and TensorFlow 2.3

TensorFlow 2.2 and 2.3 support multiple GPU profiling for single host systems only; multiple GPU profiling for multi-host systems is not supported. To profile multi-worker GPU configurations, each worker has to be profiled independently. From TensorFlow 2.4 multiple workers can be profiled using the tf.profiler.experimental.client.trace API.

CUDA® Toolkit 10.2 or later is required to profile multiple GPUs. As TensorFlow 2.2 and 2.3 support CUDA® Toolkit versions only up to 10.1, you need to create symbolic links to libcudart.so.10.1 and libcupti.so.10.1 :

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1