Monitorare il goodput con la libreria ML Goodput Measurement

La libreria ML Goodput Measurement (ml-goodput-measurement) è un pacchetto Python che ti aiuta a misurare l'efficienza dei carichi di lavoro di addestramento ML in esecuzione sulle VM Cloud TPU. La libreria fornisce metriche che misurano il goodput del carico di lavoro, ovvero la proporzione del tempo di utilizzo della TPU dedicato a progressi di addestramento produttivi e conservati. Al contrario, il badput è la proporzione del tempo totale dedicato ad attività non produttive come l'overhead di avvio, i blocchi di I/O e il ripristino da interruzioni.

Puoi visualizzare le metriche di goodput in tempo reale con Cloud Monitoring dashboard e TensorBoard, il che ti consente di individuare colli di bottiglia, ottimizzare l'utilizzo delle risorse e, in definitiva, ridurre i costi di addestramento.

Per saperne di più, consulta il repository GitHub di ML Goodput Measurement.

Metriche di goodput

La libreria ML Goodput Measurement fornisce le seguenti metriche, che sono disponibili anche per la visualizzazione in Cloud Monitoring e TensorBoard. Le metriche in questa tabella devono avere il prefisso compute.googleapis.com/workload/. Ad esempio, il nome completo della metrica per goodput_time è compute.googleapis.com/workload/goodput_time.

  • goodput_time: il tempo di addestramento produttivo totale in secondi. Può essere interpretato come il goodput cumulativo.

  • badput_time: il tempo di addestramento non produttivo totale in secondi (avvio, blocchi, ripristino). Può essere interpretato come il badput cumulativo.

  • total_elapsed_time: il tempo trascorso totale (durata dell'orologio) del carico di lavoro in secondi. Il tempo trascorso viene misurato dal momento in cui l'applicazione viene avviata fino all'ora attuale o all'ora di completamento del job.

  • interval_goodput: la velocità di goodput in un periodo di tempo specificato (ad esempio, le ultime 24 ore). La metrica fornisce una finestra mobile per il goodput.

  • interval_badput: la velocità di badput in un periodo di tempo specificato. La metrica fornisce una finestra mobile per il badput ed è utile per identificare problemi temporanei come picchi nelle operazioni di I/O.

  • disruptions: il conteggio cumulativo delle interruzioni del job. Le interruzioni sono eventi che causano l'arresto imprevisto del processo di addestramento, che richiede un riavvio. Ad esempio, guasti hardware ed eventi di manutenzione.

  • step_time_deviation: la quantità di tempo non produttivo dovuta alla variazione dei tempi dei passaggi di addestramento. È anche noto come "jitter". La metrica misura la stabilità sensibile ai picchi, ovvero la deviazione dei passaggi "worst-case" recenti rispetto a una baseline storica in secondi. Un passaggio è una singola iterazione del ciclo di addestramento.

  • performance: il tempo di passaggio stabile più veloce stimato (baseline) in secondi. Il tempo di passaggio ideale è il tempo più veloce che un singolo passaggio di addestramento può richiedere in condizioni ottimali, senza rumore transitorio o jitter.

  • max_productive_steps: il conteggio dei passaggi più alto raggiunto che è stato conservato correttamente.

Installazione

Per configurare la libreria ML Goodput Measurement con i carichi di lavoro TPU:

  1. Abilita l'API Cloud Logging e l'API Cloud Monitoring.
  2. Se esegui il deployment su Google Kubernetes Engine (GKE), configura tutti i pool di nodi con l'ambito di accesso cloud-platform.

Installa il pacchetto ml-goodput-measurement sull'host di addestramento e sulla macchina di analisi:

pip install ml-goodput-measurement

Monitorare con la libreria Goodput

Per utilizzare la libreria ML Goodput Measurement, inizializza un'istanza GoodputRecorder, strumenta il codice di addestramento racchiudendo le sezioni chiave con il gestore di contesto record_event e monitora le metriche in tempo reale con GoodputMonitor. Il monitor esegue un processo in background per calcolare periodicamente le metriche di goodput dagli eventi registrati e le carica in Cloud Monitoring e TensorBoard per l'analisi e la visualizzazione in tempo reale.

Inizializzare il registratore Goodput

Inizializza GoodputRecorder, il componente principale della libreria ML Goodput Measurement.

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

Registrare eventi

Utilizza il gestore di contesto record_event per racchiudere il codice di addestramento.

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

Per un esempio di come il codice di addestramento può essere integrato con la libreria Goodput utilizzando MaxText, consulta goodput.py.

Monitorare eventi

Monitora le metriche con GoodputMonitor, che avvia un processo in background per calcolare e caricare le metriche durante l'esecuzione del job. Racchiudi la logica in un gestore di contesto per assicurarti che il processo di caricamento venga avviato e arrestato come previsto.

Definisci un gestore di contesto helper per gestire la configurazione e il ciclo di vita.

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

Per misurare il rendimento della finestra mobile, configura il monitor in modo che utilizzi start_rolling_window_goodput_uploader e 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()

Racchiudi il punto di ingresso principale dell'addestramento con il gestore di contesto. In questo modo, il monitoraggio inizia prima dell'addestramento e le metriche finali vengono cancellate al termine dell'addestramento.

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)

Post-elaborazione e analisi

Puoi calcolare le metriche di goodput per un job completato da qualsiasi macchina, ad esempio una VM CPU standard o il tuo laptop. Non è necessario utilizzare una TPU per la post-elaborazione e l'analisi.

Il seguente codice restituisce il goodput totale del job:

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

Per informazioni sui tipi di badput (BadputType), consulta Dettagli della suddivisione del badput.

Per specificare una finestra temporale specifica, utilizza get_job_goodput_interval:

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

L'ora di inizio (start_time_utc) e l'ora di fine (end_time_utc) sono oggetti datetime. Per saperne di più, consulta goodput.py.

Monitorare con le dashboard di Goodput

Per aiutarti a monitorare e visualizzare i carichi di lavoro di addestramento di machine learning, Google Cloud offre due set di dashboard di Goodput: la dashboard di goodput di GKE JobSet e la dashboard di goodput di Cloud ML. Utilizza la dashboard di GKE JobSet per diagnosticare problemi di infrastruttura o pianificazione e le dashboard di goodput di Cloud ML per individuare i colli di bottiglia all'interno del codice di addestramento.

Google Cloud Dashboard di goodput di ML

La dashboard di goodput di ML misura l'efficienza a livello di applicazione dello script di addestramento. Fornisce informazioni dettagliate sul tempo dedicato all'addestramento produttivo e sulle origini di badput come il caricamento dei dati, l'inizializzazione o il ripristino da interruzioni.

Per visualizzare la dashboard di goodput di ML in Cloud Monitoring:

  1. Nella Google Cloud console, vai alla pagina Cloud Monitoring.
    Vai alla console di Monitoring
  2. Nel riquadro di navigazione, fai clic su Dashboard.
  3. Nel campo Filtra ricerca, inserisci "Dashboard di goodput di Cloud ML".

La dashboard di goodput di ML include le seguenti metriche (con il prefisso workload/):

  • goodput_time: tempo cumulativo dedicato ai passaggi di addestramento produttivi.
  • badput_time: tempo cumulativo dedicato ad attività non produttive, insieme all'origine di badput:
    • ACCELERATOR_INITIALIZATION: tempo per configurare le TPU.
    • TRAINING_PREP: caricamento del checkpoint, creazione del modello e dell'ottimizzatore.
    • PROGRAM_STARTUP: compilazione JIT, tracciamento del grafico.
    • DATA_LOADING_SYNC: tempo trascorso bloccato sull'input dei dati.
    • CHECKPOINT_SAVE: tempo per salvare lo stato del modello.
    • CHECKPOINT_RESTORE: tempo per ripristinare lo stato del modello.
    • WASTED_PROGRESS: tempo produttivo perso a causa di interruzioni avvenute prima di un checkpoint.
    • INFRASTRUCTURE_RECOVERY: tempo di inattività durante i riavvii del job.
    • CUSTOM_BADPUT_EVENTS: eventi sincroni definiti dall'utente, ad esempio le valutazioni.
  • step_time_deviation: misura il jitter e l'instabilità nei tempi dei passaggi di addestramento.
  • interval_goodput: goodput calcolato su finestre mobili (ad es. l'ultima ora).

Dashboard di GKE JobSet

La dashboard di goodput di GKE JobSet si concentra sull'efficienza del livello di orchestrazione e ti aiuta a capire se GKE sta pianificando rapidamente i pod e mantenendoli in esecuzione.

Per visualizzare informazioni complete sull'integrità e sul rendimento di JobSet, vai alla dashboard Monitoraggio di JobSet nella Google Cloud console:

Vai alla dashboard di monitoraggio di JobSet

La dashboard di monitoraggio di JobSet include le seguenti metriche:

  • kubernetes.io/jobset/scheduling_goodput: la frazione di tempo in cui tutte le risorse richieste (pod) per JobSet sono in stato Pronto e disponibili per il lavoro, rispetto al tempo di creazione di JobSet. Valori bassi indicano ritardi nella pianificazione dei pod, nel pull delle immagini o nell'allocazione delle risorse in GKE.

  • kubernetes.io/jobset/proxy_runtime_goodput: una frazione di tempo stimata in cui le TPU vengono utilizzate attivamente, in base a segnali a livello di sistema come il ciclo di lavoro dell'acceleratore. Fornisce una visualizzazione di alto livello della produttività di runtime senza strumentazione dell'applicazione.

  • Metriche del pool di nodi: Informazioni sull'integrità, la disponibilità e le interruzioni che interessano i pool di nodi che ospitano JobSet. In questo modo è possibile correlare i cali di goodput con i problemi dei nodi sottostanti.

Per saperne di più sulla dashboard di GKE JobSet, consulta Monitorare il goodputdi JobSet.

Guida alla risoluzione dei problemi

Questa sezione fornisce informazioni per la risoluzione dei problemi per aiutarti a identificare e risolvere i problemi comuni che potresti riscontrare durante l'utilizzo della libreria ML Goodput Measurement.

Metriche di Cloud Monitoring mancanti

Se mancano le metriche di Cloud Monitoring:

  • Verifica le autorizzazioni IAM: il account di servizio collegato al carico di lavoro deve disporre delle autorizzazioni monitoring.timeSeries.create e monitoring.metricDescriptors.create.
  • Controlla la configurazione: le metriche di goodput devono essere abilitate esplicitamente nella configurazione. Ad esempio, verifica che enable_gcp_goodput_metrics=True sia passato all'interno di GCPOptions.

Metriche generali mancanti

Se mancano le metriche generali:

  • Verifica lo stato del monitor: il monitoraggio deve essere abilitato per l'istanza del monitor. Passa monitoring_enabled=True al monitor.

Metriche danneggiate

Se le metriche sono danneggiate o mostrano valori strani:

  • Assicurati che i nomi delle esecuzioni siano univoci: tutti i valori run_name devono essere univoci per ogni esperimento. Il riutilizzo di un nome di esecuzione combinerà i log delle esecuzioni precedenti e di quelle nuove.

Log mancanti

Se mancano i log di Cloud Logging:

  • Abilita l'API Cloud Logging: l'API Cloud Logging deve essere abilitata nel tuo Google Cloud progetto.
  • Controlla le impostazioni del registratore: il flag logging_enabled=True deve essere passato al registratore Goodput.
  • Verifica il processo principale: il processo principale (dove jax.process_index() == 0) deve segnalare attivamente i log delle applicazioni.

Checkpoint di badput mancanti

Se mancano i checkpoint di badput:

  • Verifica la libreria di checkpoint: la libreria Goodput tiene traccia automaticamente del tempo di checkpoint per Orbax. Tuttavia, se utilizzi altre librerie (ad esempio il checkpoint di PyTorch), devi racchiudere manualmente le chiamate di salvataggio e ripristino utilizzando record_custom_badput_event_start_time e record_custom_badput_event_end_time.