Monitorar o goodput com a biblioteca de medição de goodput de ML

A biblioteca de medição de goodput de ML (ml-goodput-measurement) é um pacote Python que ajuda a medir a eficiência das cargas de trabalho de treinamento de ML executadas em VMs do Cloud TPU. A biblioteca fornece métricas que medem o goodput da carga de trabalho, que é a proporção do tempo de uso da TPU gasto para fazer um progresso de treinamento produtivo e preservado. Por outro lado, o badput é a proporção do tempo total gasto em atividades não produtivas, como sobrecarga de inicialização, interrupções de E/S e recuperação de interrupções.

É possível visualizar as métricas de goodput em tempo real com os painéis do Cloud Monitoring e TensorBoard, permitindo identificar gargalos, otimizar a utilização de recursos e, por fim, reduzir os custos de treinamento.

Para mais informações, consulte o repositório do GitHub de medição de goodput de ML.

Métricas de goodput

A biblioteca de medição de goodput de ML fornece as seguintes métricas, que também estão disponíveis para visualização no Cloud Monitoring e no TensorBoard. As métricas nesta tabela precisam ser prefixadas com compute.googleapis.com/workload/. Por exemplo, o nome completo da métrica goodput_time é compute.googleapis.com/workload/goodput_time.

goodput_time: o tempo total de treinamento produtivo em segundos. Isso pode ser interpretado como o goodput cumulativo.
badput_time: o tempo total de treinamento não produtivo em segundos (inicialização, interrupções, recuperação). Isso pode ser interpretado como o badput cumulativo.
total_elapsed_time: o tempo total decorrido (duração do relógio de parede) da carga de trabalho em segundos. O tempo decorrido é medido desde o início do aplicativo até o horário atual ou o horário de conclusão do job.
interval_goodput: a taxa de goodput em um período especificado (por exemplo, as últimas 24 horas). A métrica fornece uma janela móvel para o goodput.
interval_badput: a taxa de badput em um período especificado. A métrica fornece uma janela móvel para o badput e é útil para identificar problemas temporários, como picos nas operações de E/S.
disruptions: a contagem cumulativa de interrupções de jobs. As interrupções são eventos que fazem com que o processo de treinamento pare inesperadamente, exigindo uma reinicialização. Por exemplo, falhas de hardware e eventos de manutenção.
step_time_deviation: a quantidade de tempo não produtivo devido à variação nos tempos de etapa de treinamento. Isso também é conhecido como "jitter". A métrica mede a estabilidade sensível a picos, que é o desvio das etapas recentes de "pior caso" em relação a uma linha de base histórica em segundos. Uma etapa é uma única iteração do loop de treinamento.
performance: o tempo de etapa estável mais rápido estimado (linha de base) em segundos. O tempo de etapa ideal é o tempo mais rápido que uma única etapa de treinamento pode levar em condições ideais, livre de ruído ou jitter temporário.
max_productive_steps: a contagem de etapas mais alta alcançada que foi preservada com sucesso.

Instalação

Siga as etapas abaixo para configurar a biblioteca de medição de goodput de ML com suas cargas de trabalho de TPU:

Ative a API Cloud Logging e a API Cloud Monitoring.
Se você estiver implantando no Google Kubernetes Engine (GKE), configure todos os pools de nós com o escopo de acesso cloud-platform.

Instale o pacote ml-goodput-measurement no host de treinamento e na máquina de análise:

pip install ml-goodput-measurement

Monitorar com a biblioteca Goodput

Para usar a biblioteca de medição de goodput de ML, inicialize uma instância GoodputRecorder, instrumente o código de treinamento envolvendo as seções principais com o gerenciador de contexto record_event e monitore as métricas em tempo real com GoodputMonitor. O monitor executa um processo em segundo plano para calcular periodicamente as métricas de goodput dos eventos registrados e as envia ao Cloud Monitoring e ao TensorBoard para análise e visualização em tempo real.

Inicializar o gravador Goodput

Inicialize o GoodputRecorder, que é o componente principal da biblioteca de medição de goodput de ML.

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

Gravar eventos

Use o gerenciador de contexto record_event para envolver o código de treinamento.

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

Para um exemplo de como o código de treinamento pode ser integrado à biblioteca Goodput usando o MaxText, consulte goodput.py.

Monitorar eventos

Monitore as métricas com GoodputMonitor, que inicia um processo em segundo plano para calcular e fazer upload de métricas enquanto o job é executado. Envolva a lógica em um gerenciador de contexto para garantir que o processo de upload seja iniciado e interrompido conforme o esperado.

Defina um gerenciador de contexto auxiliar para processar a configuração e o gerenciamento do ciclo de vida.

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

Para medir o desempenho da janela móvel, configure o monitor para usar 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()

Envolva o ponto de entrada de treinamento principal com o gerenciador de contexto. Isso garante que o monitoramento seja iniciado antes do treinamento e que as métricas finais sejam limpas quando o treinamento terminar.

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)

Pós-processamento e análise

É possível calcular métricas de goodput para um job concluído em qualquer máquina, como uma VM de CPU padrão ou um laptop. Não é necessário usar uma TPU para pós-processamento e análise.

O código a seguir gera o goodput total do 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]}%")

Para informações sobre tipos de badput (BadputType), consulte Detalhes do detalhamento de badput.

Para especificar uma janela de tempo específica, use get_job_goodput_interval:

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

O horário de início (start_time_utc) e o horário de término (end_time_utc) são objetos de data e hora. Para mais informações, consulte goodput.py (em inglês).

Monitorar com painéis do Goodput

Para ajudar a monitorar e visualizar as cargas de trabalho de treinamento de machine learning, Google Cloud oferece dois conjuntos de painéis do Goodput: o painel do GKE JobSet Goodput e o painel do Cloud ML Goodput. Use o painel do GKE JobSet para diagnosticar problemas de infraestrutura ou programação e os painéis do Cloud ML Goodput para identificar gargalos no código de treinamento.

Google Cloud Painel do ML Goodput

O painel do ML Goodput mede a eficiência no nível do aplicativo do script de treinamento. Ele fornece insights sobre o tempo gasto no treinamento produtivo e fontes de badput, como carregamento de dados, inicialização ou recuperação de interrupções.

Para visualizar o painel do ML Goodput no Cloud Monitoring:

No Google Cloud console, acesse a página do Cloud Monitoring.
Acessar o console do Monitoring
No painel de navegação, clique em Painéis.
No campo Pesquisa de filtros, insira "Painel do ML Goodput".

O painel do ML Goodput inclui as seguintes métricas (prefixadas com workload/):

goodput_time: tempo cumulativo gasto em etapas de treinamento produtivo.
badput_time: tempo cumulativo gasto em atividades não produtivas, juntamente com a fonte de badput:
- ACCELERATOR_INITIALIZATION: tempo para configurar as TPUs.
- TRAINING_PREP: carregamento de checkpoint, criação de modelo e otimizador.
- PROGRAM_STARTUP: compilação JIT, rastreamento de gráficos.
- DATA_LOADING_SYNC: tempo gasto bloqueado na entrada de dados.
- CHECKPOINT_SAVE: tempo para salvar o estado do modelo.
- CHECKPOINT_RESTORE: tempo para restaurar o estado do modelo.
- WASTED_PROGRESS: tempo produtivo perdido devido a interrupções que ocorrem antes de um checkpoint.
- INFRASTRUCTURE_RECOVERY: tempo de inatividade durante as reinicializações do job.
- CUSTOM_BADPUT_EVENTS: eventos síncronos definidos pelo usuário, como avaliações.
step_time_deviation: mede o jitter e a instabilidade nos tempos de etapa de treinamento.
interval_goodput: goodput calculado em janelas móveis (por exemplo, a última hora).

Painel do GKE JobSet

O painel do GKE JobSet Goodput se concentra na eficiência da camada de orquestração e ajuda a entender se o GKE está programando pods rapidamente e mantendo-os em execução.

Para conferir informações abrangentes sobre a integridade e o desempenho dos JobSets, acesse o painel Monitoramento do JobSet no Google Cloud console:

Acessar o painel de monitoramento do JobSet

O painel de monitoramento do JobSet inclui as seguintes métricas:

kubernetes.io/jobset/scheduling_goodput: a fração de tempo em que todos os recursos necessários (pods) para o JobSet estão em um estado pronto e disponíveis para trabalhar, em relação ao horário de criação do JobSet. Valores baixos indicam atrasos no agendamento de pods, na extração de imagens ou na alocação de recursos no GKE.
kubernetes.io/jobset/proxy_runtime_goodput: uma fração estimada de tempo em que as TPUs estão sendo usadas ativamente, com base em indicadores no nível do sistema, como o ciclo de trabalho do acelerador. Isso fornece uma visão geral da produtividade do ambiente de execução sem instrumentação de aplicativos.
Métricas do pool de nós: Informações sobre a integridade, a disponibilidade e as interrupções que afetam os pools de nós que hospedam o JobSet. Isso ajuda a correlacionar quedas de goodput com problemas de nós subjacentes.

Para mais informações sobre o painel do GKE JobSet, consulte Monitor goodput do JobSet.

Guia de solução de problemas

Esta seção fornece informações de solução de problemas para ajudar a identificar e resolver problemas comuns que podem ocorrer ao usar a biblioteca de medição de goodput de ML.

Métricas ausentes do Cloud Monitoring

Se você não tiver métricas do Cloud Monitoring:

Verifique as permissões do IAM:a conta de serviço anexada à carga de trabalho precisa ter as permissões monitoring.timeSeries.create e monitoring.metricDescriptors.create.
Verifique a configuração:as métricas de goodput precisam ser ativadas explicitamente na configuração. Por exemplo, verifique se enable_gcp_goodput_metrics=True é transmitido no GCPOptions.

Métricas gerais ausentes

Se você não tiver métricas gerais:

Verifique o status do monitor:o monitoramento precisa estar ativado para a instanciação do monitor. Transmita monitoring_enabled=True ao monitor.

Métricas corrompidas

Se as métricas estiverem corrompidas ou mostrando valores estranhos:

Garanta nomes de execução exclusivos:todos os valores run_name precisam ser exclusivos para cada experimento. A reutilização de um nome de execução vai misturar registros de execuções antigas e novas.

Registros ausentes

Se você não tiver registros do Cloud Logging:

Ative a API Cloud Logging: a API Cloud Logging precisa estar ativada no seu Google Cloud projeto.
Verifique as configurações do gravador:o indicador logging_enabled=True precisa ser transmitido ao gravador Goodput.
Verifique o processo principal: O processo principal (em que jax.process_index() == 0) precisa estar informando ativamente os registros de aplicativos.

Checkpoints de badput ausentes

Se você não tiver checkpoints de badput:

Verifique a biblioteca de checkpoint:a biblioteca Goodput rastreia automaticamente o tempo de checkpoint para o Orbax. No entanto, se você estiver usando outras bibliotecas (como o checkpoint do PyTorch), será necessário envolver manualmente as chamadas de salvar e restaurar usando record_custom_badput_event_start_time e record_custom_badput_event_end_time.