Goodput mit der ML Goodput Measurement-Bibliothek überwachen

Die Bibliothek zur Messung des ML-Goodput (ml-goodput-measurement) ist ein Python-Paket, mit dem Sie die Effizienz Ihrer ML-Trainingsarbeitslasten auf Cloud TPU-VMs messen können. Die Bibliothek bietet Messwerte, mit denen der Durchsatz von Arbeitslasten gemessen wird. Das ist der Anteil der TPU-Nutzungszeit, in der produktive, erhaltene Trainingsfortschritte erzielt werden. „Badput“ ist der Anteil der Gesamtzeit, der für unproduktive Aktivitäten wie Start-up-Overhead, E/A-Stalls und die Wiederherstellung nach Unterbrechungen aufgewendet wird.

Sie können Goodput-Messwerte in Echtzeit mit Cloud Monitoring-Dashboards und TensorBoard visualisieren. So lassen sich Engpässe erkennen, die Ressourcennutzung optimieren und letztendlich die Trainingskosten senken.

Weitere Informationen finden Sie im GitHub-Repository für die Messung des ML-Goodput.

Messwerte für den effektiven Durchsatz

Die ML Goodput Measurement-Bibliothek bietet die folgenden Messwerte, die auch in Cloud Monitoring und TensorBoard verfügbar sind. Den Messwerten in dieser Tabelle muss das Präfix compute.googleapis.com/workload/ vorangestellt werden. Der vollständige Messwertname für goodput_time ist beispielsweise compute.googleapis.com/workload/goodput_time.

  • goodput_time: Die gesamte produktive Trainingszeit in Sekunden. Das kann als kumulativer Goodput interpretiert werden.

  • badput_time: Die gesamte ineffiziente Trainingszeit in Sekunden (Start, Unterbrechungen, Wiederherstellung). Das kann als kumulativer Badput interpretiert werden.

  • total_elapsed_time: Die gesamte verstrichene Zeit (Wanduhrendauer) des Arbeitslast in Sekunden. Die verstrichene Zeit wird ab dem Start der Anwendung bis zur aktuellen Zeit oder bis zum Abschluss des Jobs gemessen.

  • interval_goodput: Die Goodput-Rate über einen bestimmten Zeitraum (z. B. die letzten 24 Stunden). Der Messwert bietet ein rollierendes Fenster für den Goodput.

  • interval_badput: Die Badput-Rate über einen angegebenen Zeitraum. Der Messwert bietet ein gleitendes Fenster für Badput und ist nützlich, um vorübergehende Probleme wie Spitzen bei E/A-Vorgängen zu erkennen.

  • disruptions: Die kumulative Anzahl von Jobunterbrechungen. Unterbrechungen sind Ereignisse, die dazu führen, dass der Trainingsprozess unerwartet beendet wird und neu gestartet werden muss. Dazu gehören beispielsweise Hardwarefehler und Wartungsereignisse.

  • step_time_deviation: Die Menge an unproduktiver Zeit aufgrund von Schwankungen bei den Trainingsschrittzeiten. Dies wird auch als „Jitter“ bezeichnet. Mit dem Messwert wird die stabilitätsbezogene Sensibilität für Spitzen gemessen. Er gibt die Abweichung der letzten „Worst-Case“-Schritte von einer historischen Baseline in Sekunden an. Ein Schritt ist eine einzelne Iteration der Trainingsschleife.

  • performance: Die geschätzte schnellste stabile Schrittzeit (Baseline) in Sekunden. Die ideale Schrittzeit ist die schnellste Zeit, die ein einzelner Trainingsschritt unter optimalen Bedingungen ohne vorübergehendes Rauschen oder Jitter dauern kann.

  • max_productive_steps: Die höchste erreichte Schrittanzahl, die erfolgreich beibehalten wurde.

Installation

Gehen Sie so vor, um die ML Goodput Measurement-Bibliothek für Ihre TPU-Arbeitslasten einzurichten:

  1. Aktivieren Sie die Cloud Logging API und die Cloud Monitoring API.
  2. Wenn Sie die Bereitstellung in Google Kubernetes Engine (GKE) vornehmen, konfigurieren Sie alle Knotenpools mit dem Zugriffsbereich cloud-platform.

Installieren Sie das ml-goodput-measurement-Paket auf Ihrem Trainingshost und Analysecomputer:

pip install ml-goodput-measurement

Mit der Goodput-Bibliothek überwachen

Wenn Sie die ML-Goodput-Messbibliothek verwenden möchten, initialisieren Sie eine GoodputRecorder-Instanz, instrumentieren Sie Ihren Trainingscode, indem Sie wichtige Abschnitte mit dem Kontextmanager record_event umschließen, und überwachen Sie Messwerte in Echtzeit mit GoodputMonitor. Der Monitor führt einen Hintergrundprozess aus, um regelmäßig Goodput-Messwerte aus den aufgezeichneten Ereignissen zu berechnen und sie zur Echtzeitanalyse und ‑visualisierung in Cloud Monitoring und TensorBoard hochzuladen.

Goodput-Recorder initialisieren

Initialisieren Sie die GoodputRecorder, die die Kernkomponente der ML-Goodput-Messbibliothek ist.

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)
)

Ereignisse aufzeichnen

Verwenden Sie den Kontextmanager record_event, um Ihren Trainingscode zu umschließen.

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()

Ein Beispiel dafür, wie Trainingscode mit der Goodput-Bibliothek mit MaxText integriert werden kann, finden Sie unter goodput.py.

Ereignisse überwachen

Messwerte mit GoodputMonitor überwachen. Dadurch wird ein Hintergrundprozess gestartet, um Messwerte während der Ausführung des Jobs zu berechnen und hochzuladen. Schließen Sie die Logik in einen Kontextmanager ein, damit der Uploader-Prozess wie vorgesehen gestartet und beendet wird.

Definieren Sie einen Hilfskontextmanager für die Konfiguration und Lebenszyklusverwaltung.

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.")

Wenn Sie die Leistung des rollierenden Zeitfensters messen möchten, konfigurieren Sie den Monitor so, dass start_rolling_window_goodput_uploader und stop_rolling_window_goodput_uploader verwendet werden.

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()

Umschließen Sie den Haupteinstiegspunkt für das Training mit dem Kontextmanager. So wird sichergestellt, dass das Monitoring vor dem Training beginnt und die endgültigen Messwerte gelöscht werden, wenn das Training endet.

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)

Nachbearbeitung und Analyse

Sie können Goodput-Messwerte für einen abgeschlossenen Job auf jedem Computer berechnen, z. B. auf einer Standard-CPU-VM oder auf Ihrem Laptop. Für die Nachbearbeitung und Analyse ist keine TPU erforderlich.

Mit dem folgenden Code wird der gesamte Job-Goodput ausgegeben:

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]}%")

Informationen zu Badput-Typen (BadputType) finden Sie unter Details zur Aufschlüsselung des Badput.

Wenn Sie ein bestimmtes Zeitfenster angeben möchten, verwenden Sie get_job_goodput_interval:

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

Die Startzeit (start_time_utc) und die Endzeit (end_time_utc) sind datetime-Objekte. Weitere Informationen finden Sie unter goodput.py.

Mit Goodput-Dashboards überwachen

Zur Überwachung und Visualisierung Ihrer Arbeitslasten für das Training von Machine-Learning-Modellen bietetGoogle Cloud zwei Arten von Goodput-Dashboards: das GKE JobSet Goodput-Dashboard und das Cloud ML Goodput-Dashboard. Verwenden Sie das GKE JobSet-Dashboard, um Infrastruktur- oder Planungsprobleme zu diagnostizieren, und die Cloud ML-Goodput-Dashboards, um Engpässe im Trainingscode zu ermitteln.

Google Cloud Dashboard für ML-Goodput

Im Dashboard „ML Goodput“ wird die Effizienz Ihres Trainingsskripts auf Anwendungsebene gemessen. Sie bietet Einblicke in die Zeit, die für produktives Training aufgewendet wird, und in Quellen für Badput wie das Laden von Daten, die Initialisierung oder die Wiederherstellung nach Unterbrechungen.

So rufen Sie das Dashboard „ML Goodput“ in Cloud Monitoring auf:

  1. Rufen Sie in der Google Cloud Console die Seite „Cloud Monitoring“ auf.
    Zur Monitoring-Konsole
  2. Klicken Sie im Navigationsbereich auf Dashboards.
  3. Geben Sie in das Feld Filtersuche „Cloud ML Goodput Dashboard“ ein.

Das Dashboard „ML Goodput“ enthält die folgenden Messwerte (mit dem Präfix workload/):

  • goodput_time: Kumulative Zeit, die für produktive Trainingsschritte aufgewendet wurde.
  • badput_time: Kumulative Zeit, die für nicht produktive Aktivitäten aufgewendet wurde, zusammen mit der Badput-Quelle:
    • ACCELERATOR_INITIALIZATION: Zeit für die Einrichtung von TPUs.
    • TRAINING_PREP: Checkpoint-Laden, Modell- und Optimiererstellung.
    • PROGRAM_STARTUP: Just-in-time-Kompilierung, Graph-Tracing.
    • DATA_LOADING_SYNC: Zeit, die mit der Dateneingabe verbracht wurde.
    • CHECKPOINT_SAVE: Zeitpunkt zum Speichern des Modellstatus.
    • CHECKPOINT_RESTORE: Zeitpunkt für die Wiederherstellung des Modellstatus.
    • WASTED_PROGRESS: Produktive Zeit, die aufgrund von Unterbrechungen vor einem Prüfpunkt verloren gegangen ist.
    • INFRASTRUCTURE_RECOVERY: Ausfallzeit während des Neustarts von Jobs.
    • CUSTOM_BADPUT_EVENTS: Nutzerdefinierte synchrone Ereignisse wie Auswertungen.
  • step_time_deviation: Misst den Jitter und die Instabilität bei den Zeiten für Trainingsschritte.
  • interval_goodput: Goodput, der über gleitende Fenster berechnet wird (z.B. letzte Stunde).

GKE JobSet-Dashboard

Das GKE JobSet Goodput-Dashboard konzentriert sich auf die Effizienz der Orchestrierungsebene und hilft Ihnen, zu verstehen, ob GKE Pods schnell plant und sie am Laufen hält.

Wenn Sie umfassende Informationen zum Zustand und zur Leistung von JobSets aufrufen möchten, rufen Sie in der Google Cloud Console das Dashboard JobSet-Monitoring auf:

Zum JobSet-Monitoring-Dashboard

Das JobSet-Monitoring-Dashboard enthält die folgenden Messwerte:

  • kubernetes.io/jobset/scheduling_goodput: Der Anteil der Zeit, in der alle erforderlichen Ressourcen (Pods) für das JobSet bereit und für die Ausführung von Aufgaben verfügbar sind, relativ zum Erstellungszeitpunkt des JobSets. Niedrige Werte deuten auf Verzögerungen bei der Pod-Planung, dem Abrufen von Images oder der Ressourcenzuweisung in GKE hin.

  • kubernetes.io/jobset/proxy_runtime_goodput: Ein geschätzter Anteil der Zeit, in der die TPUs aktiv verwendet werden, basierend auf Signalen auf Systemebene wie dem Arbeitszyklus des Beschleunigers. So erhalten Sie einen allgemeinen Überblick über die Laufzeitproduktivität ohne Anwendungsinstrumentierung.

  • Knotenpool-Messwerte: Informationen zum Zustand, zur Verfügbarkeit und zu Unterbrechungen der Knotenpools, in denen das JobSet gehostet wird. So lassen sich Einbrüche beim Goodput mit zugrunde liegenden Knotenproblemen in Verbindung bringen.

Weitere Informationen zum GKE JobSet-Dashboard finden Sie unter JobSet-Durchsatz überwachen.

Tipps zur Fehlerbehebung

Dieser Abschnitt enthält Informationen zur Fehlerbehebung, mit denen Sie häufige Probleme bei der Verwendung der ML Goodput Measurement Library erkennen und beheben können.

Fehlende Cloud Monitoring-Messwerte

Wenn Cloud Monitoring-Messwerte fehlen:

  • IAM-Berechtigungen prüfen:Das Dienstkonto, das Ihrer Arbeitslast zugeordnet ist, muss die Berechtigungen monitoring.timeSeries.create und monitoring.metricDescriptors.create haben.
  • Konfiguration prüfen:Goodput-Messwerte müssen explizit in Ihrer Konfiguration aktiviert sein. Prüfen Sie beispielsweise, ob enable_gcp_goodput_metrics=True in Ihrem GCPOptions übergeben wird.

Allgemeine Messwerte fehlen

Wenn allgemeine Messwerte fehlen:

  • Monitorstatus prüfen:Die Überwachung muss für die Instanziierung des Monitors aktiviert sein. Übergeben Sie monitoring_enabled=True an den Monitor.

Beschädigte Messwerte

Wenn Ihre Messwerte beschädigt sind oder ungewöhnliche Werte angezeigt werden:

  • Eindeutige Ausführungsnamen: Alle run_name-Werte müssen für jeden Test eindeutig sein. Wenn Sie einen Namen für einen Lauf wiederverwenden, werden Logs aus alten und neuen Läufen gemischt.

Fehlende Logs

Wenn Logs in Cloud Logging fehlen:

  • Cloud Logging API aktivieren:Die Cloud Logging API muss in IhremGoogle Cloud -Projekt aktiviert sein.
  • Recorder-Einstellungen prüfen:Das Flag logging_enabled=True muss an den Goodput Recorder übergeben werden.
  • Hauptprozess prüfen:Der primäre Prozess (mit jax.process_index() == 0) muss aktiv Anwendungslogs melden.

Fehlende Badput-Prüfpunkte

Wenn Badput-Prüfpunkte fehlen:

  • Prüfpunktbibliothek überprüfen:Die Goodput-Bibliothek erfasst automatisch die Prüfpunktzeit für Orbax. Wenn Sie jedoch andere Bibliotheken verwenden (z. B. PyTorch-Checkpointing), müssen Sie Ihre Speicher- und Wiederherstellungsaufrufe manuell mit record_custom_badput_event_start_time und record_custom_badput_event_end_time umschließen.