מעקב אחרי מדדים של מסגרת עומסי העבודה

במאמר הזה מוסבר איך לאסוף מדדים של Megascale XLA‏ (MXLA),‏ Orbax ו-PyGrain‏ (Grain) לעומסי עבודה של Cloud TPU שפועלים ב-Google Kubernetes Engine‏ (GKE), ואיך להציג אותם. בנוסף, מוסבר איך להציג מנתחים שמבוססים על המדדים האלה בפלטפורמת ML Diagnostics. מעקב אחרי המדדים האלה מאפשר לזהות ולפתור צווארי בקבוק בביצועים בתקשורת בין פרוסות, בנקודות הבדיקה ובטעינת הנתונים.

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

  • מדדי Megascale XLA ‏(MXLA): מודדים את זמני האחזור של ההעברה ברשת של מרכז הנתונים (DCN) בין פרוסות, את זמני ההעברה ממכשיר למארח (D2H) וממארח למכשיר (H2D), את זמן האחזור של החישוב ואת הפעולות הקולקטיביות מקצה לקצה בעומסי עבודה של TPU עם ריבוי פרוסות. אפשר להשתמש במדדים האלה כדי לזהות משימות שמתעכבות וצווארי בקבוק בחומרה.
  • מדדי Orbax: מעקב אחרי שמירות אסינכרוניות של נקודות ביקורת ומשך השחזור, נפח הנתונים וקצב העברת הנתונים לכתיבה מספריית נקודות הביקורת של Orbax. אתם יכולים להשתמש במדדים האלה כדי לזהות עיכובים או עצירות בנקודות הבקרה, או זמן חסימה מוגזם של שרשורי האימון.
  • ‫מדדי PyGrain (Grain)‎: מודדים את זמן האחזור של החזרות על מערך הנתונים, זמני הקריאה של מקור הנתונים, סך הבייטים שנקראו ומוכנות מאגר הנתונים לשליפה מראש מספריית טעינת הנתונים של PyGrain. אתם יכולים להשתמש במדדים האלה כדי לקבוע אם עומס העבודה מוגבל לקלט בגלל צווארי בקבוק של קלט/פלט או של טעינת נתונים.

אתם יכולים לגשת למדדים האלה דרך יציאת Prometheus שאתם קוראים ישירות, ספריית המעקב של TPU, ה-CLI של tpu-info או Cloud Monitoring.

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

מדדים בקנה מידה עצום

‫Megascale XLA (MXLA) הוא סביבת זמן ריצה לתקשורת ותוסף לקומפיילר, שמתאם פעולות קולקטיביות בין כמה פרוסות TPU ברשת של מרכז הנתונים (DCN). קישורי Inter-Chip Interconnect‏ (ICI) מטפלים בתקשורת במהירות גבוהה בין שבבי TPU בתוך פרוסה אחת, ו-MXLA מנהל את העברות הנתונים בין פרוסות, הפחתות בצד המארח ותנועת נתונים בין זיכרון המארח לבין זיכרון ברוחב פס גבוה (HBM) של TPU.

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

בטבלה הבאה מפורטים המדדים הזמינים של Megascale:

שם המדד שם המדד ב-GKE תיאור
זמן האחזור של העברת MXLA DCN container/multislice/network/dcn_transfer_latencies

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

למדד יש את המאפיינים הבאים:

  • סוג המדד: CUMULATIVE
  • סוג הערך: DISTRIBUTION
  • יחידה: מיקרו-שניות (us)
זמן האחזור של העברה נכנסת ב-MXLA container/multislice/network/dcn_inbound_transfer_latencies

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

למדד יש את המאפיינים הבאים:

  • סוג המדד: CUMULATIVE
  • סוג הערך: DISTRIBUTION
  • יחידה: מיקרו-שניות (us)
זמן האחזור של חישוב MXLA container/multislice/accelerator/compute_latencies

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

למדד יש את המאפיינים הבאים:

  • סוג המדד: CUMULATIVE
  • סוג הערך: DISTRIBUTION
  • יחידה: מיקרו-שניות (us)
זמן האחזור הקולקטיבי מקצה לקצה של MXLA container/multislice/network/collective_end_to_end_latencies

מודד את זמן האחזור הקולקטיבי מקצה לקצה ב-DCN, מהרגע שהמארח מתחיל את הפעולה ועד שכל עמיתי הרשת מקבלים את הפלט. כולל צמצום נתונים בצד המארח ושליחת פלט ל-TPU. התוצאות הן מחרוזות שמפרטות את שטח האחסון הזמני, סוג הפעולה וזמני האחזור הממוצעים, P50, ‏ P90, ‏ P95 ו-P99.9.

למדד יש את המאפיינים הבאים:

  • סוג המדד: CUMULATIVE
  • סוג הערך: DISTRIBUTION
  • יחידה: מיקרו-שניות (us)
זמן האחזור של MXLA d2h container/multislice/accelerator/device_to_host_transfer_latencies

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

למדד יש את המאפיינים הבאים:

  • סוג המדד: CUMULATIVE
  • סוג הערך: DISTRIBUTION
  • יחידה: מיקרו-שניות (us)
זמן האחזור של MXLA h2d container/multislice/accelerator/host_to_device_transfer_latencies

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

למדד יש את המאפיינים הבאים:

  • סוג המדד: CUMULATIVE
  • סוג הערך: DISTRIBUTION
  • יחידה: מיקרו-שניות (us)

מדדי Orbax

‫Orbax היא ספריית נקודות בקרה מבוזרת לעומסי עבודה של JAX, ששומרת ומשחזרת משקלי מודלים, מצבי אופטימיזציה ואיטרטורים של קבוצות נתונים בסביבות של מארח יחיד ומארחים מרובים. כדי לצמצם את זמן ההשבתה של האימון, Orbax תומך בנקודות ביקורת אסינכרוניות, שמעתיקות מצבים מזיכרון ה-TPU לזיכרון המארח במהלך השלב הסינכרוני, ואז כותבות את נקודת הביקורת לאחסון בשרשור ברקע בזמן שהאימון נמשך.

אם עומס העבודה משתמש ב-Orbax לנקודות בקרה, אתם יכולים לאסוף מדדי Orbax כדי לפתור בעיות שקשורות לעיכובים בנקודות הבקרה, לקצב העברה איטי של כתיבה או לתקיעות. ‫Orbax מייצא את המדדים האלה ביציאת Prometheus, שאפשר לקרוא ישירות או לשלוח ל-Cloud Monitoring באמצעות השירות המנוהל של Google Cloud ל-Prometheus. כדי להפעיל את המדדים האלה ב-GKE, ב-Cloud Monitoring או ב-ML Diagnostics, קראו את המאמר גישה למדדים של Orbax ו-PyGrain.

בטבלה הבאה מפורטים המדדים הזמינים של Orbax:

שם המדד ב-Prometheus תיאור
jax_checkpoint_write_async_total_duration_secs

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

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/checkpoint/write/async/total_duration_secs
  • סוג המדד: היסטוגרמה
  • יחידה: שניות (s)
jax_orbax_write_gbytes

מספר הג'יגה-בייטים הכולל שנכתבו במהלך פעולת שמירה של נקודת ביקורת.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/orbax/write/gbytes
  • סוג המדד: היסטוגרמה
  • יחידה: ג'יגה-בייט (GBy)
jax_orbax_write_gbytes_per_sec

קצב העברת הנתונים בכתיבה בג'יגה-בייט לשנייה (GBps) בשלבים הסינכרוניים והאסינכרוניים של פעולת שמירה של נקודת ביקורת.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/orbax/write/gbytes_per_sec
  • סוג המדד: היסטוגרמה
  • יחידה: ג'יגה-בייט לשנייה (GBps)
jax_checkpoint_write_async_blocking_duration_secs

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

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/checkpoint/write/async/blocking_duration_secs
  • סוג המדד: היסטוגרמה
  • יחידה: שניות (s)
jax_orbax_read_total_duration_secs

משך הזמן הכולל של פעולת שחזור מנקודת ביקורת.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/orbax/read/total_duration_secs
  • סוג המדד: היסטוגרמה
  • יחידה: שניות (s)
jax_orbax_read_blocking_duration_secs

משך שלב ההכנה הסינכרוני (החוסם) של פעולת שחזור מנקודת ביקורת.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/orbax/read/blocking_duration_secs
  • סוג המדד: היסטוגרמה
  • יחידה: שניות (s)
jax_orbax_write_async_start_total

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

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /jax/orbax/write/async/start
  • סוג המדד: מונה
  • יחידה: ספירה (1)

מדדי PyGrain

‫PyGrain (Grain) היא ספריית Python לקריאה, לעיבוד מראש ולעיבוד באצווה של נתוני קלט לעומסי עבודה של אימון והערכה של למידת מכונה. ‫PyGrain מספק פייפליינים דטרמיניסטיים וניתנים לשחזור, שמאחזרים מראש רשומות ומשנים אותן ב-CPU המארח, כדי שמאיצי TPU לא יתעכבו בזמן ההמתנה לקבוצות של קלט.

אם עומס העבודה שלכם משתמש ב-PyGrain לטעינת נתונים, אתם יכולים לאסוף מדדי PyGrain כדי לפתור בעיות של צווארי בקבוק בצינור עיבוד הנתונים של הקלט, קריאות אחסון איטיות או מאגרי נתונים זמניים (buffers) מרוקנים של אחזור מראש. ‫PyGrain מייצא את המדדים האלה ביציאת Prometheus, שאפשר לקרוא ישירות או לשלוח ל-Cloud Monitoring באמצעות השירות המנוהל של Google Cloud ל-Prometheus. כדי להפעיל את המדדים האלה ב-GKE, ב-Cloud Monitoring או ב-ML Diagnostics, קראו את המאמר גישה למדדים של Orbax ו-PyGrain.

בטבלה הבאה מפורטים המדדים הזמינים של PyGrain:

שם המדד ב-Prometheus תיאור
grain_python_dataset_next_duration_ns

הזמן שנדרש להפעלת ה-method‏ next בקבוצת הנתונים.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /grain/python/dataset/next_duration_ns
  • סוג המדד: היסטוגרמה
  • יחידה: ננו-שניות (ns)
grain_python_dataset_prefetch_buffer_ready_count

מספר הרכיבים המוכנים במאגר הנתונים לשליפה מראש.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /grain/python/dataset/prefetch_buffer_ready_count
  • סוג המדד: היסטוגרמה
  • יחידה: ספירה (1)
grain_python_data_sources_bytes_read_total

סך כל הבייטים שנקראו ממקורות הנתונים.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /grain/python/data_sources/bytes_read
  • סוג המדד: מונה
  • ‫Unit: בייטים (By)
grain_python_dataset_source_read_time_ns

הזמן שנדרש לקריאה ממקור הנתונים.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /grain/python/dataset/source_read_time_ns
  • סוג המדד: היסטוגרמה
  • יחידה: ננו-שניות (ns)
grain_python_data_loader_iterator_get_next

הזמן שנדרש להפעלת ה-method‏ next של המחלקה DataLoaderIterator.

למדד יש את המאפיינים הבאים:

  • נתיב המדד: /grain/python/data_loader/iterator_get_next
  • סוג המדד: היסטוגרמה
  • יחידה: ננו-שניות (ns)

דרישות מוקדמות

לפני שאתם אוספים מדדים של Megascale, ‏ Orbax או PyGrain, או משתמשים במנתחים המשויכים של ML Diagnostics, ודאו שהסביבה שלכם עומדת בדרישות שמפורטות בקטעים הבאים.

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

כדי לאסוף מדדי Megascale ולראות אותם ב-Cloud Monitoring, צריך לעמוד בדרישות הגרסה הבאות:

  • מתקינים את LibTPU בגרסה 0.40.0 ואילך.
  • כדי לראות את המדדים האלה ב-Cloud Monitoring, צריך להתקין את גרסה 1.36.4-gke.1247000 של GKE או גרסה עדכנית יותר.

דרישות Orbax ו-PyGrain

כדי לייצא מדדים של Orbax ו-PyGrain מעומס העבודה, צריך לעמוד בדרישות הבאות לגבי החבילה והקונטיינר:

  • thought חבילות Python:
    • מתקינים את גרסה 0.12.1 או גרסה חדשה יותר של Orbax‏ (orbax-checkpoint).
    • מתקינים את PyGrain (grain) בגרסה 0.2.18 ואילך.
    • מתקינים את חבילת Python של prometheus-client בקובץ האימג' של הקונטיינר. החבילה orbax-checkpoint מתקינה את prometheus-client באופן אוטומטי כתלות, אבל לא את grain. אם עומס העבודה משתמש רק ב-PyGrain, מתקינים את החבילה באמצעות הפקודה pip install prometheus-client.
  • הגדרת מאגר עומסי העבודה:
    • מגדירים את משתני הסביבה הבאים:
      • ‫ENABLE_ORBAX_PROMETHEUS_TELEMETRY="true" (מפעיל מדדי Orbax)
      • ‫ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY="true" (מפעיל מדדים של PyGrain)
    • חושפים את יציאת ה-TCP‏ 9431 בקונטיינר של עומס העבודה.

בדוגמה הבאה, מפרט הקונטיינר מגדיר את משתני הסביבה של הטלמטריה וחושף את יציאת ה-TCP‏ 9431:

containers:
- name: WORKLOAD_CONTAINER
  env:
  - name: ENABLE_ORBAX_PROMETHEUS_TELEMETRY
    value: "true"
  - name: ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY
    value: "true"
  ports:
  - name: framework-metrics
    containerPort: 9431
    protocol: TCP

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

הדרישות של כלי הניתוח לאבחון בעיות ב-ML

כדי להשתמש בכלי הניתוח של ML Diagnostics למדדים של Megascale,‏ Orbax ו-PyGrain, צריך להתקין את GKE בגרסה 1.36.4-gke.1247000 ואילך.

גישה למדדים של Megascale

כשהאשכול מריץ גרסה נתמכת של GKE ו-LibTPU,‏ GKE אוסף באופן אוטומטי מדדי Megascale כדי שתוכלו לראות אותם ב-Cloud Monitoring. אתם יכולים גם לפרוס אוסף Prometheus לבחירתכם כדי לקרוא מדדי Megascale ישירות מיציאת Prometheus של סביבת זמן הריצה של MXLA.

גישה למדדים של Orbax ו-PyGrain

כשמפעילים את הטלמטריה של Prometheus בקונטיינר של עומס העבודה, Orbax ו-PyGrain מייצאים מדדים ביציאת TCP‏ 9431. אפשר לגשת למדדים האלה באחת מהדרכים הבאות:

  • קריאה ישירה של נקודת הקצה של Prometheus: פורסים אוסף Prometheus לבחירתכם כדי לקרוא את המדדים של Orbax ו-PyGrain מיציאה 9431 במאגר של עומס העבודה.
  • שליחת מדדים ל-Cloud Monitoring: משתמשים בשירות המנוהל של Google Cloud ל-Prometheus כדי לקרוא את יציאה 9431 בכל צומת ולשלוח את המדדים ל-Cloud Monitoring.

הצגת מדדים באמצעות השירות המנוהל של Google Cloud ל-Prometheus

כדי לשלוח מדדי Orbax ו-PyGrain מיציאה 9431 ל-Cloud Monitoring, צריך לפרוס משאב בהתאמה אישית של השירות המנוהל של Google Cloud ל-Prometheus PodMonitoring באשכול GKE. המשאב PodMonitoring מורה לאספן של השירות המנוהל של Google Cloud ל-Prometheus בכל צומת לקרוא את יציאה 9431 ולשלוח את המדדים ל-Cloud Monitoring. מידע נוסף זמין במאמר הגדרת משאב PodMonitoring.

נקודת הקצה prometheus.googleapis.com והאוסף של השירות המנוהל של Google Cloud ל-Prometheus מופעלים כברירת מחדל באשכולות GKE. השימוש בשירות המנוהל של Google Cloud ל-Prometheus כרוך בחיובים נוספים.

הפעלת אוסף מנוהל

איסוף מנוהל של השירות המנוהל של Google Cloud ל-Prometheus מופעל כברירת מחדל באשכולות GKE Standard שפועלת בהם גרסה 1.27 ואילך של GKE. מידע נוסף זמין במאמר הפעלת איסוף מנוהל.

אם האיסוף המנוהל מושבת באשכול, צריך להפעיל אותו:

gcloud container clusters update CLUSTER_NAME \
  --enable-managed-prometheus \
  --region=REGION

מחליפים את מה שכתוב בשדות הבאים:

  • ‫CLUSTER_NAME: השם של אשכול GKE.
  • ‫REGION: האזור שבו נמצא האשכול.

אם שיניתם את הרשאות ברירת המחדל בחשבון השירות של הצומת, ודאו שיש לו את התפקיד Monitoring Metric Writer (roles/monitoring.metricWriter).

הגדרת תבנית ה-Pod של עומס העבודה

כדי להכין את ה-Pods של עומס העבודה לגירוד, מעדכנים את תבנית ה-Pod במניפסט של JobSet,‏ Job או Deployment:

  1. מוסיפים תווית Pod, כמו ml-framework-metrics: "enabled", כדי שהמשאב PodMonitoring יוכל לבחור את ה-Pods של עומס העבודה.
  2. מגדירים את משתני הסביבה ENABLE_ORBAX_PROMETHEUS_TELEMETRY ו-ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY לערך "true".
  3. חושפים את יציאת ה-TCP‏ 9431 ומקצים לה שם, למשל framework-metrics.

בתבנית הפוד הבאה מוגדרים השדות האלה:

template:
  metadata:
    labels:
      ml-framework-metrics: "enabled"     # used by the PodMonitoring selector
  spec:
    containers:
    - name: WORKLOAD_CONTAINER
      env:
      - name: ENABLE_ORBAX_PROMETHEUS_TELEMETRY
        value: "true"
      - name: ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY
        value: "true"
      ports:
      - name: framework-metrics
        containerPort: 9431
        protocol: TCP

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

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

לפני שפורסים את המשאב PodMonitoring, צריך לוודא שמאגר עומס העבודה מייצא מדדים ביציאה 9431. מעבירים את היציאה 9431 מ-Pod של עומס עבודה שפועל, ושולחים שאילתה לנקודת הקצה (endpoint) של /metrics:

kubectl -n NAMESPACE port-forward pod/WORKLOAD_POD 9431:9431
curl -s localhost:9431/metrics | grep -E '^(jax_orbax|jax_checkpoint|grain_python)'

מחליפים את מה שכתוב בשדות הבאים:

  • ‫NAMESPACE: מרחב השמות של Kubernetes שבו פועל עומס העבודה.
  • ‫WORKLOAD_POD: השם של Pod פעיל של עומס עבודה.

‫Orbax מאתחל כל מדד בפעם הראשונה שהוא מתעד ערך, כך שהמדדים של Orbax מופיעים רק אחרי הפעולה הראשונה של שמירה או שחזור של נקודת ביקורת.

פריסת המשאב PodMonitoring

כדי להגדיר את השירות המנוהל של Google Cloud ל-Prometheus לקרוא את ה-Pods של עומסי העבודה:

  1. שומרים את המניפסט הבא בתור orbax-grain-podmonitoring.yaml:

    apiVersion: monitoring.googleapis.com/v1
    kind: PodMonitoring
    metadata:
      name: orbax-grain-metrics
      namespace: WORKLOAD_NAMESPACE  # must match the workload namespace
    spec:
      selector:
        matchLabels:
          ml-framework-metrics: "enabled"
      endpoints:
      - port: framework-metrics             # the named containerPort (9431)
        path: /metrics
        interval: 30s                        # a longer interval reduces sample volume and cost
        metricRelabeling:                    # optional: keep only Orbax and PyGrain series to control cost
        - action: keep
          sourceLabels: [__name__]
          regex: (jax_orbax_|jax_checkpoint_|grain_python_).+
      targetLabels:                          # optional: copy the JobSet name onto every series
        fromPod:
        - from: jobset.sigs.k8s.io/jobset-name
          to: jobset_name
    

    מחליפים את WORKLOAD_NAMESPACE במרחב השמות של Kubernetes שבו פועל עומס העבודה.

  2. מחילים את המניפסט ומוודאים שנוצר המשאב PodMonitoring:

    kubectl apply -f orbax-grain-podmonitoring.yaml
    kubectl get podmonitoring -A
    

משאב PodMonitoring קורא Pods רק במרחב השמות שלו. אם עומסי העבודה פועלים בכמה מרחבי שמות, צריך להשתמש באותו מפרט עם kind: ClusterPodMonitoring ולהשמיט את השדה metadata.namespace. משאב ClusterPodMonitoring מגלה פודים תואמים בכל מרחבי השמות.

אופציונלי: מוודאים שהשירות המנוהל של Google Cloud ל-Prometheus אוסף נתונים מה-Pods

כדי לוודא שהשירות המנוהל של Google Cloud ל-Prometheus אוסף נתונים מהפודים של עומסי העבודה:

  1. במרחב השמות gmp-public, עורכים את המשאב OperatorConfig ומגדירים את features.targetStatus.enabled כ-true.
  2. בודקים את המשאב PodMonitoring ומוודאים שהיעדים מדווחים על Health: up:

    kubectl -n NAMESPACE describe podmonitoring/orbax-grain-metrics
    

    מחליפים את NAMESPACE במרחב השמות של Kubernetes שבו פועל עומס העבודה.

  3. אחרי שתסיימו לפתור את הבעיות, הגדירו את features.targetStatus.enabled בחזרה ל-false במשאב OperatorConfig. מומלץ להפעיל את סטטוס היעד רק כשבודקים בעיות פעילות.

שליחת שאילתות על המדדים ב-Cloud Monitoring

כדי לשלוח שאילתות לגבי המדדים שנשלחו ל-Cloud Monitoring:

  1. במסוף Google Cloud , נכנסים לדף Monitoring > Metrics Explorer.
  2. בוחרים באפשרות PromQL ומזינים את השאילתה הבאה כדי לוודא שהיעדים מדווחים:

    up{namespace="NAMESPACE"}
    

    מחליפים את NAMESPACE במרחב השמות של Kubernetes של עומס העבודה.

בבורר המדדים שמבוסס על תפריט, המדדים מאוחסנים בפורמט prometheus.googleapis.com/METRIC_NAME/TYPE, כאשר TYPE הוא counter,‏ histogram או gauge. כל ספרייה יוצרת את שם המדד של Prometheus מנתיב המדד שלה, על ידי החלפת / ב-_. למונים מצורפת הסיומת _total, והיסטוגרמות מיוצאות כסדרות הזמנים _bucket,‏ _sum ו-_count.

אתם יכולים להשתמש בשאילתות PromQL לדוגמה הבאות כדי לנתח את המדדים של Orbax ו-PyGrain:

# Asynchronous checkpoint saves started per Pod
sum by (pod) (increase(jax_orbax_write_async_start_total[1h]))

# Average time training is blocked by asynchronous checkpointing
sum(rate(jax_checkpoint_write_async_blocking_duration_secs_sum[10m]))
  / sum(rate(jax_checkpoint_write_async_blocking_duration_secs_count[10m]))

# PyGrain P99 dataset iterator next() latency (nanoseconds)
histogram_quantile(0.99, sum by (le) (rate(grain_python_dataset_next_duration_ns_bucket[5m])))

# PyGrain bytes read per second, by data source
sum by (source) (rate(grain_python_data_sources_bytes_read_total[5m]))

# Median prefetch-buffer readiness (low values can indicate an I/O bottleneck)
histogram_quantile(0.5, sum by (le) (rate(grain_python_dataset_prefetch_buffer_ready_count_bucket[5m])))

שיקולי עלות

החיוב על השירות המנוהל של Google Cloud ל-Prometheus מבוסס על מספר הדגימות שנקלטו. כדי להפחית את העלויות, אפשר להגדיר interval ארוך יותר לאיסוף נתונים ולהשתמש ב-metricRelabeling כדי לשמור רק את סדרות הזמנים שצריך. אפשר לראות את נפח ההטמעה של כל מדד בדף Metrics Management ב-Cloud Monitoring.

הצגת פלט של מנתחים ב-ML Diagnostics

מעקב אחרי עומסי עבודה באמצעות כלי אבחון מבוססי-ML ומדדי מערכת לפי ההקשר של עומסי העבודה מופעלים באופן אוטומטי לעומסי עבודה של GKE TPU JobSet ו-Job שפועלים ב-GKE מגרסה 1.36.4-gke.1247000 ואילך. מעקב אחרי עומסי עבודה מאפשר לעקוב אחרי מחזור העבודה המצטבר של TPU בעומס העבודה. אם יש ירידה של 15% או יותר במחזור העבודה (performance degradation), כלי האבחון של ML מריצים מנתחים בשכבות התשתית, התזמור וה-framework.

אם עומס העבודה פועל בכמה פרוסות (באמצעות שכבת MXLA) או משתמש בספריות PyGrain או Orbax, הכלי "אבחון ML" מריץ את מנתחי המסגרות הבאים כדי לקבוע אם הפגיעה בביצועים נגרמה בגלל זמן האחזור של ההעברה ברשת, טעינת הנתונים או נקודות הבדיקה האסינכרוניות:

הדוחות של כלי הניתוח "אבחון למידת מכונה" ניתנים ללא תשלום נוסף, וכדי ליצור את תוצאות הניתוח לא צריך להגדיר את השירות המנוהל של Google Cloud ל-Prometheus למדדים של Orbax ו-PyGrain. בכרטיסייה System metrics במסוף ML Diagnostics Google Cloud , המדדים של Megascale מופיעים באופן אוטומטי כשמשתמשים בגרסאות נתמכות של LibTPU ו-GKE.

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

  • מסוףGoogle Cloud : במסוף ML Diagnostics Google Cloud (ראו הצגת הרצות של למידת מכונה), פותחים את הכרטיסייה Monitoring overview, מוצאים את האירוע performance degradation ולוחצים על View details כדי לבדוק את דוח הניתוח.
  • ‫Google Cloud CLI או API בארכיטקטורת REST: משתמשים בפקודות monitored-events כדי להציג רשימה של אירועים ודוחות של מנתח האירועים, ולתאר אותם. מידע נוסף זמין במאמר תחילת השימוש ב-CLI של אבחון למידת מכונה.