מעקב אחרי קצב העברת נתונים יעיל באמצעות ספריית ML Goodput Measurement

הספרייה ML Goodput Measurement‏ (ml-goodput-measurement) היא חבילת Python שעוזרת למדוד את היעילות של עומסי העבודה של אימון ML שפועלים במכונות וירטואליות של Cloud TPU. הספרייה מספקת מדדים למדידת התפוקה של עומס העבודה, כלומר החלק מזמן השימוש ב-TPU שמוקדש להתקדמות פרודוקטיבית ושמורה בתהליך ההכשרה. לעומת זאת, badput הוא החלק היחסי של הזמן הכולל שמוקדש לפעילויות לא פרודוקטיביות כמו תקורה של הפעלה, השהיות של קלט/פלט (I/O) והתאוששות מהפרעות.

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

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

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

ספריית ML Goodput Measurement מספקת את המדדים הבאים, שזמינים גם ב-Cloud Monitoring וב-TensorBoard. לפני המדדים בטבלה הזו צריך להוסיף את הקידומת compute.googleapis.com/workload/. לדוגמה, השם המלא של המדד goodput_time הוא compute.googleapis.com/workload/goodput_time.

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

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

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

• ‫interval_goodput: קצב התפוקה הטובה במהלך תקופת זמן מסוימת (לדוגמה, במהלך 24 השעות האחרונות). המדד מספק חלון זמן מתגלגל לנתוני התפוקה.

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

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

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

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

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

התקנה

כדי להגדיר את ספריית ML Goodput Measurement עם עומסי העבודה של TPU:

1. מפעילים את Cloud Logging API ואת Cloud Monitoring API.
2. אם פורסים ב-Google Kubernetes Engine‏ (GKE), צריך להגדיר את כל מאגרי הצמתים עם היקף הגישה cloud-platform.

מתקינים את חבילת ml-goodput-measurement במארח האימונים ובמכונת הניתוח:

pip install ml-goodput-measurement

מעקב באמצעות ספריית Goodput

כדי להשתמש בספריית ML Goodput Measurement, צריך לאתחל מופע של GoodputRecorder, להוסיף קוד למעקב אחרי קוד האימון על ידי הוספת מנהל ההקשר record_event סביב קטעים מרכזיים ולעקוב אחרי מדדים בזמן אמת באמצעות GoodputMonitor. הכלי מריץ תהליך ברקע כדי לחשב מעת לעת מדדים של קצב העברת נתונים יעיל מהאירועים שתועדו, ומעלה אותם ל-Cloud Monitoring ול-TensorBoard לצורך ניתוח והדמיה בזמן אמת.

אתחול של כלי ההקלטה של Goodput

מפעילים את GoodputRecorder, שהוא רכיב הליבה של ספריית המדידה של ML Goodput.

import datetime
import jax
from ml_goodput_measurement import measurement

# Define a unique logger name for this specific run
logger_name = f'goodput_{config.run_name}'

# Instantiate the recorder
goodput_recorder = measurement.GoodputRecorder(
    job_name=config.run_name,
    logger_name=logger_name,
    logging_enabled=(jax.process_index() == 0)
)

הקלטת אירועים

משתמשים בrecord_event context manager כדי לעטוף את קוד האימון.

def train_loop(config):

  # 1. Wrap the entire Job (Start/End)
  with goodput_recorder.record_event(measurement.Event.JOB):

    # 2. Record Hardware Initialization
    with goodput_recorder.record_event(measurement.Event.ACCELERATOR_INIT):
      # ... perform device mesh setup ...
      initialize_tpu(config)

    # 3. Record Training Prep
    with goodput_recorder.record_event(measurement.Event.TRAINING_PREP):
      # ... create checkpoint managers, setup model ...
      model = training_prep(config)

    # 4. Main Training Loop
    for step in range(config.steps):

      # Record Data Loading
      with goodput_recorder.record_event(measurement.Event.DATA_LOADING):
        batch = get_next_batch()

      # Record Step Start (CRITICAL: Pass the step number!)
      with goodput_recorder.record_event(measurement.Event.STEP, step):
        output = train_step(model, batch)

      # 5. Record Custom Events (e.g., Evaluation)
      if step % eval_interval == 0:
        with goodput_recorder.record_event(measurement.Event.CUSTOM, "eval_step"):
          run_evaluation()

דוגמה לשילוב קוד אימון עם ספריית Goodput באמצעות MaxText מופיעה בקובץ goodput.py.

מעקב אחרי אירועים

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

מגדירים מנהל הקשר מסייע לטיפול בהגדרה ובניהול מחזור החיים.

import contextlib
from ml_goodput_measurement import monitoring

@contextlib.contextmanager
def maybe_monitor_goodput(config):
  """Monitor goodput if enabled and on the main process."""
  if not config.monitor_goodput or jax.process_index() != 0:
    yield
    return

  goodput_monitor = None
  try:
    # Configure GCPOptions for Cloud Monitoring
    gcp_options = monitoring.GCPOptions(
      enable_gcp_goodput_metrics=config.enable_gcp_goodput_metrics
    )

    # Instantiate the monitor
    goodput_monitor = monitoring.GoodputMonitor(
      job_name=config.run_name,
      logger_name=f"goodput_{config.run_name}",
      tensorboard_dir=config.tensorboard_dir,
      upload_interval=config.goodput_upload_interval_seconds,
      monitoring_enabled=True,
      pathway_enabled=config.enable_pathways_goodput,
      include_badput_breakdown=True,
      gcp_options=gcp_options,
    )

    # Start the background upload process
    goodput_monitor.start_goodput_uploader()
    print("Started Goodput upload to Tensorboard & GCM in the background!")
    yield

  finally:
    # Ensure clean shutdown of the background process
    if goodput_monitor:
      goodput_monitor.stop_goodput_uploader()
      print("Flushed final metrics and safe exited from Goodput monitoring.")

כדי למדוד את הביצועים של חלון נע, מגדירים את הכלי לניטור כך שישתמש ב-start_rolling_window_goodput_uploader וב-stop_rolling_window_goodput_uploader.

try:
    self._rolling_window_monitor.start_rolling_window_goodput_uploader(
        self.config.rolling_window_size
    )
finally:
    if self._rolling_window_monitor:
        self._rolling_window_monitor.stop_rolling_window_goodput_uploader()

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

def main():
  # ... Load configuration ...

  # Wrap the entire execution
  with maybe_monitor_goodput(config):
    # Run the training loop (which contains the GoodputRecorder events)
    train_loop(config)

עיבוד וניתוח אחרי ההמרה

אפשר לחשב מדדי goodput למשימה שהושלמה מכל מכונה, כמו מכונה וירטואלית (VM) עם מעבד מרכזי רגיל או מהמחשב הנייד. לא צריך להשתמש ב-TPU לעיבוד ולאנליזה אחרי ההמרה.

הקוד הבא מציג את התפוקה הכוללת של העבודה:

from ml_goodput_measurement import goodput

calculator = goodput.GoodputCalculator(
    job_name="my-run-name",
    logger_name="goodput_my-run-name"
)

goodput, badput, last_step = calculator.get_job_goodput(
    include_badput_breakdown=True
)

print(f"Goodput: {goodput}%")
print(f"Badput (Infra Recovery): {badput[goodput.BadputType.INFRASTRUCTURE_RECOVERY_FROM_DISRUPTION]}%")

מידע על סוגי badput (BadputType) זמין במאמר פירוט של badput.

כדי לציין חלון זמן ספציפי, משתמשים ב-get_job_goodput_interval:

goodput_pct, badput, _, _, _ = calculator.get_job_goodput_interval(
    start_time_utc,
    end_time_utc
)

שעת ההתחלה (start_time_utc) ושעת הסיום (end_time_utc) הן אובייקטים של datetime. מידע נוסף זמין במאמר בנושא goodput.py.

מעקב באמצעות לוחות בקרה של Goodput

כדי לעזור לכם לעקוב אחרי עומסי העבודה של אימון למידת מכונה ולהמחיש אותם,Google Cloud מציע שתי קבוצות של לוחות בקרה של Goodput: לוח הבקרה GKE JobSet Goodput ולוח הבקרה Cloud ML Goodput. משתמשים בלוח הבקרה של GKE JobSet כדי לאבחן בעיות בתשתית או בתזמון, ובלוחות הבקרה של Cloud ML Goodput כדי לזהות צווארי בקבוק בקוד האימון.

Google Cloud מרכז הבקרה של ML Goodput

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

כדי להציג את לוח הבקרה של ML Goodput ב-Cloud Monitoring:

1. נכנסים לדף Cloud Monitoring במסוף Google Cloud .
   כניסה למסוף Monitoring
2. בחלונית הניווט, לוחצים על מרכזי בקרה.
3. בשדה Filter search, מזינים Cloud ML Goodput Dashboard.

לוח הבקרה של ML Goodput כולל את המדדים הבאים (עם הקידומת workload/):

• ‫goodput_time: הזמן המצטבר שהוקדש לשלבי אימון פרודוקטיביים.
• ‫badput_time: הזמן המצטבר שהוקדש לפעילויות לא פרודוקטיביות, יחד עם מקור הנתונים של ה-badput:
  • ‫ACCELERATOR_INITIALIZATION: הזמן שנדרש להגדרת יחידות TPU.
  • ‫TRAINING_PREP: טעינת נקודת ביקורת, יצירת מודל ואופטימיזציה.
  • ‫PROGRAM_STARTUP: הידור JIT, מעקב אחר גרפים.
  • ‫DATA_LOADING_SYNC: הזמן שחלף עד שהמשתמש נחסם בגלל הזנת נתונים.
  • ‫CHECKPOINT_SAVE: הזמן לשמירת מצב המודל.
  • ‫CHECKPOINT_RESTORE: הזמן לשחזור מצב המודל.
  • ‫WASTED_PROGRESS: זמן פרודוקטיבי שאבד בגלל שיבושים שקרו לפני נקודת ביקורת.
  • ‫INFRASTRUCTURE_RECOVERY: זמן השבתה במהלך הפעלה מחדש של משימות.
  • ‫CUSTOM_BADPUT_EVENTS: אירועים סינכרוניים שהוגדרו על ידי המשתמש, כמו הערכות.
• ‫step_time_deviation: מדד של הג'יטר וחוסר היציבות בזמני שלבי האימון.
• ‫interval_goodput: קצב העברת נתונים נטו שמחושב על חלונות זמן מתגלגלים (למשל, בשעה האחרונה).

לוח הבקרה של GKE JobSet

לוח הבקרה של GKE JobSet Goodput מתמקד ביעילות של שכבת התזמור, ועוזר לכם להבין אם GKE מתזמן פודים במהירות ושומר על הפעלתם.

כדי לראות מידע מקיף על התקינות והביצועים של JobSet, עוברים אל מרכז הבקרה JobSet monitoring במסוף Google Cloud :

מעבר ללוח הבקרה של מעקב אחר JobSet

לוח הבקרה למעקב אחר JobSet כולל את המדדים הבאים:

• ‫kubernetes.io/jobset/scheduling_goodput: חלקיק הזמן שבו כל המשאבים הנדרשים (pods) של JobSet נמצאים במצב מוכן וזמינים לביצוע עבודה, ביחס לזמן היצירה של JobSet. ערכים נמוכים מצביעים על עיכובים בתזמון של פודים, בשליפה של תמונות או בהקצאת משאבים ב-GKE.

• ‫kubernetes.io/jobset/proxy_runtime_goodput: חלק משוער מהזמן שבו נעשה שימוש פעיל ב-TPU, על סמך אותות ברמת המערכת כמו מחזור הפעילות של המאיץ. כך אפשר לקבל סקירה כללית של הפרודוקטיביות בזמן הריצה בלי להשתמש במכשיר למדידת ביצועים של אפליקציות.

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

מידע נוסף על לוח הבקרה של GKE JobSet זמין במאמר מעקב אחרי תפוקת נתונים (goodput) של JobSet.

מדריך לפתרון בעיות

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

מדדים חסרים ב-Cloud Monitoring

אם חסרים לכם מדדים של Cloud Monitoring:

• אימות הרשאות IAM: לחשבון השירות שמצורף לעומס העבודה צריכות להיות ההרשאות monitoring.timeSeries.create ו-monitoring.metricDescriptors.create.
• בדיקת ההגדרה: צריך להפעיל באופן מפורש את מדדי Goodput בהגדרה. לדוגמה, מוודאים שהערך enable_gcp_goodput_metrics=True מועבר בתוך GCPOptions.

חסרים מדדים כלליים

אם חסרים מדדים כלליים:

• אימות סטטוס המעקב: צריך להפעיל את המעקב כדי ליצור מופע של כלי המעקב. מעבירים את monitoring_enabled=True לצג.

מדדים פגומים

אם המדדים פגומים או מציגים ערכים מוזרים:

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

יומנים חסרים

אם חסרים לכם יומנים מ-Cloud Logging:

• מפעילים את Cloud Logging API: צריך להפעיל את Cloud Logging API בפרויקטGoogle Cloud .
• בדיקת ההגדרות של מכשיר ההקלטה: צריך להעביר את הדגל logging_enabled=True אל Goodput Recorder.
• אימות התהליך הראשי: התהליך הראשי (שמסומן ב-jax.process_index() == 0) צריך לדווח באופן פעיל על יומני האפליקציה.

נקודות ביקורת חסרות של פלט לא תקין

אם חסרות לכם נקודות ביקורת של badput:

• אימות ספריית נקודות הבדיקה: ספריית Goodput עוקבת באופן אוטומטי אחרי זמן נקודות הבדיקה של Orbax. עם זאת, אם אתם משתמשים בספריות אחרות (כמו PyTorch checkpointing), אתם צריכים להוסיף ידנית את התגים record_custom_badput_event_start_time ו-record_custom_badput_event_end_time לקריאות של הפונקציות save ו-restore.