Monitorar métricas do framework de carga de trabalho
Neste documento, explicamos como coletar e visualizar as métricas do Megascale XLA (MXLA), do Orbax e do PyGrain (Grain) para cargas de trabalho do Cloud TPU em execução no Google Kubernetes Engine (GKE) e como visualizar analisadores criados com base nessas métricas na plataforma de diagnóstico de ML. Ao monitorar essas métricas, é possível identificar e resolver gargalos de desempenho na comunicação de várias frações, na criação de checkpoints e no carregamento de dados.
Cada conjunto de métricas é direcionado a um componente distinto da carga de trabalho para ajudar você a diagnosticar problemas em diferentes estágios do pipeline:
- Métricas do Megascale XLA (MXLA): meça as latências de transferência da rede de data center (DCN) entre frações, os tempos de transferência de dispositivo para host (D2H) e de host para dispositivo (H2D), a latência de computação e as operações coletivas de ponta a ponta em cargas de trabalho de TPU de várias frações. Use essas métricas para identificar retardatários e gargalos de hardware.
- Métricas do Orbax: acompanhe as durações de salvamento e restauração de checkpoints assíncronos, o volume de dados e a capacidade de gravação da biblioteca de checkpoints do Orbax. Use essas métricas para detectar atrasos, interrupções ou tempo excessivo de bloqueio de linhas de execução de treinamento.
- Métricas do PyGrain (Grain): meça a latência de iteração do conjunto de dados, os tempos de leitura da fonte de dados, o total de bytes lidos e a prontidão do buffer de pré-busca da biblioteca de carregamento de dados do PyGrain. Use essas métricas para determinar se a carga de trabalho está limitada por entrada devido a gargalos de E/S ou de carregamento de dados.
É possível acessar essas métricas por uma porta do Prometheus
que você lê diretamente, pela biblioteca de monitoramento
da TPU, pela
CLI tpu-info ou pelo Cloud Monitoring.
A plataforma ML Diagnostics também inclui analisadores de monitoramento de carga de trabalho que analisam automaticamente essas métricas quando uma carga de trabalho apresenta degradação de desempenho. Esses analisadores determinam se uma queda no ciclo de trabalho da TPU é causada pela latência de transferência de rede do MXLA, pelo checkpoint assíncrono do Orbax ou pelo carregamento de dados do PyGrain.
Métricas de megaescala
O Megascale XLA (MXLA) é um ambiente de execução de comunicação e uma extensão de compilador que coordena operações coletivas em várias frações de TPU pela rede de data center (DCN). Enquanto os links de interconexão entre chips (ICI) lidam com a comunicação de alta velocidade entre chips de TPU em uma única fração, o MXLA gerencia transferências de dados entre frações, reduções do lado do host e movimentação de dados entre a memória do host e a memória de alta largura de banda (HBM) da TPU.
Ao executar cargas de trabalho de várias frações em TPUs, é possível coletar métricas do MXLA para resolver problemas de rede entre frações e gargalos de processamento de host. O GKE coleta essas métricas por padrão como métricas do sistema do GKE, e é possível visualizá-las no Cloud Monitoring. As métricas também ficam disponíveis automaticamente na guia de métricas do sistema do ML Diagnostics, em que são agregadas automaticamente para o contexto da carga de trabalho de execução de ML.
A tabela a seguir lista as métricas do Megascale disponíveis:
| Nome da métrica | Nome da métrica do GKE | Descrição |
|---|---|---|
| Latência de transferência da DCN do MXLA | container/multislice/network/dcn_transfer_latencies |
Mede a latência de transferência de ida e volta da rede de data center (DCN, na sigla em inglês) para cada bloco de dados. Os outliers podem estar correlacionados com hardware de rede defeituoso. A métrica tem as seguintes propriedades:
|
| Latência de transferência de entrada da MXLA | container/multislice/network/dcn_inbound_transfer_latencies |
Mede a latência de transferência de entrada unidirecional da DCN para cada bloco de dados. Os outliers podem estar relacionados a hardware de rede com defeito. A métrica tem as seguintes propriedades:
|
| Latência de computação do MXLA | container/multislice/accelerator/compute_latencies |
Mede a latência de computação do host necessária para concluir uma operação de redução. Os outliers podem indicar problemas de CPU ou memória, como falhas no módulo de memória em linha dupla (DIMM, na sigla em inglês). A métrica tem as seguintes propriedades:
|
| Latência coletiva de ponta a ponta do MXLA | container/multislice/network/collective_end_to_end_latencies |
Mede a latência coletiva de ponta a ponta na DCN, desde o momento em que o host inicia a operação até o momento em que todos os peers recebem a saída. Isso inclui a redução de dados do lado do host e o envio da saída para a TPU. Os resultados são strings que detalham o tamanho do buffer, o tipo de operação e as latências média, P50, P90, P95 e P99,9. A métrica tem as seguintes propriedades:
|
| Latência d2h da MXLA | container/multislice/accelerator/device_to_host_transfer_latencies |
Mede a latência de transferência unidirecional de dispositivo para host (D2H) para cada bloco de dados. Os outliers podem estar relacionados a hardware de rede com defeito. A métrica tem as seguintes propriedades:
|
| Latência h2d do MXLA | container/multislice/accelerator/host_to_device_transfer_latencies |
Mede a latência de transferência unidirecional de host para dispositivo (H2D) para cada bloco de dados. Os outliers podem estar relacionados a hardware de rede com defeito. A métrica tem as seguintes propriedades:
|
Métricas do Orbax
O Orbax é uma biblioteca de checkpoint distribuída para cargas de trabalho do JAX que salva e restaura pesos de modelo, estados do otimizador e iteradores de conjunto de dados em ambientes de host único e de vários hosts. Para minimizar o tempo de inatividade do treinamento, o Orbax é compatível com a criação de checkpoints assíncrona, que copia estados da memória da TPU para a memória do host durante a fase síncrona e, em seguida, grava o checkpoint no armazenamento em uma linha de execução em segundo plano enquanto o treinamento continua.
Se a carga de trabalho usar o Orbax para checkpoints, será possível coletar métricas do Orbax para resolver problemas de atrasos, lentidão na capacidade de gravação ou travamentos. O Orbax exporta essas métricas em uma porta do Prometheus, que pode ser lida diretamente ou enviada ao Cloud Monitoring usando o Serviço Gerenciado do Google Cloud para Prometheus. Para ativar essas métricas no GKE, no Cloud Monitoring ou no ML Diagnostics, consulte Acessar métricas do Orbax e do PyGrain.
A tabela a seguir lista as métricas disponíveis do Orbax:
| Nome da métrica do Prometheus | Descrição |
|---|---|
jax_checkpoint_write_async_total_duration_secs |
Tempo total de todo o pipeline de gravação de checkpoint assíncrono. A métrica tem as seguintes propriedades:
|
jax_orbax_write_gbytes |
Total de gigabytes gravados durante uma operação de salvamento de checkpoint. A métrica tem as seguintes propriedades:
|
jax_orbax_write_gbytes_per_sec |
Capacidade de gravação em gigabytes por segundo (GBps) nas fases síncronas e assíncronas de uma operação de salvamento de checkpoint. A métrica tem as seguintes propriedades:
|
jax_checkpoint_write_async_blocking_duration_secs |
Tempo gasto na fase de bloqueio de um salvamento de checkpoint assíncrono antes de passar para a linha de execução em segundo plano. A métrica tem as seguintes propriedades:
|
jax_orbax_read_total_duration_secs |
Duração total de ponta a ponta de uma operação de restauração de checkpoint. A métrica tem as seguintes propriedades:
|
jax_orbax_read_blocking_duration_secs |
Duração da fase de preparação síncrona (bloqueio) de uma operação de restauração de checkpoint. A métrica tem as seguintes propriedades:
|
jax_orbax_write_async_start_total |
Contagem de operações de gravação de checkpoint assíncronas iniciadas. A métrica tem as seguintes propriedades:
|
Métricas do PyGrain
O PyGrain (Grain) é uma biblioteca Python para ler, pré-processar e agrupar dados de entrada para cargas de trabalho de treinamento e avaliação de machine learning. O PyGrain fornece pipelines de dados determinísticos e reproduzíveis que buscam e transformam registros na CPU do host para que os aceleradores de TPU não fiquem parados esperando por lotes de entrada.
Se a carga de trabalho usa o PyGrain para carregamento de dados, é possível coletar métricas do PyGrain para resolver problemas de gargalos de pipeline de entrada, leituras de armazenamento lentas ou buffers de pré-busca esgotados. O PyGrain exporta essas métricas em uma porta do Prometheus, que pode ser lida diretamente ou enviada ao Cloud Monitoring usando o Google Cloud Managed Service para Prometheus. Para ativar essas métricas no GKE, no Cloud Monitoring ou no ML Diagnostics, consulte Acessar métricas do Orbax e do PyGrain.
A tabela a seguir lista as métricas disponíveis do PyGrain:
| Nome da métrica do Prometheus | Descrição |
|---|---|
grain_python_dataset_next_duration_ns |
Tempo gasto na chamada de método A métrica tem as seguintes propriedades:
|
grain_python_dataset_prefetch_buffer_ready_count |
Número de elementos prontos no buffer de pré-busca. A métrica tem as seguintes propriedades:
|
grain_python_data_sources_bytes_read_total |
Total de bytes lidos das fontes de dados. A métrica tem as seguintes propriedades:
|
grain_python_dataset_source_read_time_ns |
Tempo gasto lendo da fonte de dados. A métrica tem as seguintes propriedades:
|
grain_python_data_loader_iterator_get_next |
Tempo gasto na chamada de método A métrica tem as seguintes propriedades:
|
Pré-requisitos
Antes de coletar métricas do Megascale, do Orbax ou do PyGrain ou usar os analisadores de diagnóstico de ML associados, verifique se o ambiente atende aos requisitos nas seções a seguir.
Requisitos de megascala
Para coletar métricas do Megascale e visualizá-las no Cloud Monitoring, atenda aos seguintes requisitos de versão:
- Instale a versão
0.40.0ou mais recente da LibTPU. - Para conferir essas métricas no Cloud Monitoring, instale a versão
1.36.4-gke.1247000ou posterior do GKE.
Requisitos do Orbax e do PyGrain
Para exportar métricas do Orbax e do PyGrain da sua carga de trabalho, atenda aos seguintes requisitos de pacote e contêiner:
- Pacotes Python:
- Instale o Orbax (
orbax-checkpoint) versão0.12.1ou mais recente. - Instale o PyGrain (
grain) versão0.2.18ou mais recente. - Instale o pacote Python
prometheus-clientna imagem do contêiner. O pacoteorbax-checkpointinstalaprometheus-clientautomaticamente como uma dependência, mas ograinnão. Se a carga de trabalho usar apenas o PyGrain, instale o pacote executandopip install prometheus-client.
- Instale o Orbax (
- Configuração do contêiner de carga de trabalho:
- Defina as seguintes variáveis de ambiente:
ENABLE_ORBAX_PROMETHEUS_TELEMETRY="true"(ativa as métricas do Orbax)ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY="true"(ativa as métricas do PyGrain)
- Exponha a porta TCP
9431no contêiner da carga de trabalho.
- Defina as seguintes variáveis de ambiente:
O exemplo de especificação de contêiner a seguir define as variáveis de ambiente de telemetria
e expõe a porta 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
Substitua WORKLOAD_CONTAINER pelo nome do contêiner de carga de trabalho.
Requisitos do analisador de diagnósticos de ML
Para usar os analisadores de diagnóstico de ML para métricas do Megascale, Orbax e PyGrain, instale o GKE versão 1.36.4-gke.1247000 ou mais recente.
Acessar métricas do Megascale
Quando o cluster executa uma versão compatível do GKE e da LibTPU, o GKE coleta automaticamente as métricas do Megascale para que você possa visualizá-las no Cloud Monitoring. Também é possível implantar um coletor do Prometheus de sua escolha para ler as métricas do Megascale diretamente da porta do Prometheus do ambiente de execução do MXLA.
Acessar métricas do Orbax e do PyGrain
Quando você ativa a telemetria do Prometheus no contêiner de carga de trabalho, o Orbax e o
PyGrain exportam métricas na porta TCP 9431. É possível acessar essas métricas de uma das seguintes maneiras:
- Ler o endpoint do Prometheus diretamente: implante um coletor do Prometheus de
sua escolha para ler as métricas do Orbax e do PyGrain na porta
9431no contêiner de carga de trabalho. - Enviar métricas para o Cloud Monitoring: use o
Google Cloud Managed Service para Prometheus para ler a porta
9431em cada nó e enviar as métricas para o Cloud Monitoring.
Ver métricas com o Google Cloud Managed Service para Prometheus
Para enviar métricas do Orbax e do PyGrain da porta 9431 para o Cloud Monitoring,
implante um recurso personalizado PodMonitoring do Google Cloud Managed Service para Prometheus no
cluster do GKE. O recurso PodMonitoring instrui o coletor do Google Cloud Managed Service para Prometheus em cada nó a ler a porta 9431 e enviar as métricas para o Cloud Monitoring. Para mais informações, consulte Configurar um recurso PodMonitoring.
O endpoint prometheus.googleapis.com e o
coletor do Google Cloud Managed Service para Prometheus são ativados por padrão em
clusters do GKE. O uso do Google Cloud Managed Service para Prometheus gera
cobranças adicionais.
Ativar a coleção gerenciada
A coleta gerenciada do Google Cloud Managed Service para Prometheus é ativada por padrão em clusters do GKE Standard que executam a versão 1.27 ou mais recente do GKE. Para mais informações, consulte Ativar a coleta gerenciada.
Se a coleta gerenciada estiver desativada no cluster, ative-a:
gcloud container clusters update CLUSTER_NAME \
--enable-managed-prometheus \
--region=REGION
Substitua:
CLUSTER_NAME: o nome do cluster do GKE.REGION: a região em que o cluster está localizado.
Se você modificou as permissões padrão na conta de serviço do nó, verifique se ela tem o papel de Gravador de Métricas do Monitoring (roles/monitoring.metricWriter).
Configurar o modelo de pod de carga de trabalho
Para preparar os pods de carga de trabalho para raspagem de dados, atualize o modelo de pod no manifesto
JobSet, Job ou Deployment:
- Adicione um rótulo de pod, como
ml-framework-metrics: "enabled", para que o recursoPodMonitoringpossa selecionar os pods de carga de trabalho. - Defina as variáveis de ambiente
ENABLE_ORBAX_PROMETHEUS_TELEMETRYeENABLE_PYGRAIN_PROMETHEUS_TELEMETRYcomo"true". - Exponha a porta TCP
9431e atribua um nome a ela, comoframework-metrics.
O exemplo de modelo de pod a seguir configura esses campos:
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
Substitua WORKLOAD_CONTAINER pelo nome do contêiner de carga de trabalho.
Verificar o endpoint de métricas
Antes de implantar o recurso PodMonitoring, verifique se o contêiner da carga de trabalho
exporta métricas na porta 9431. Encaminhe a porta 9431 de um pod de carga de trabalho em execução e consulte o 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)'
Substitua:
NAMESPACE: o namespace do Kubernetes em que a carga de trabalho é executada.WORKLOAD_POD: o nome de um pod de carga de trabalho em execução.
O Orbax inicializa cada métrica na primeira vez que registra um valor. Portanto, as métricas do Orbax aparecem somente após a primeira operação de salvamento ou restauração do checkpoint.
Implantar o recurso PodMonitoring
Para configurar o Google Cloud Managed Service para Prometheus para ler os pods de carga de trabalho, siga estas etapas:
Salve o seguinte manifesto como
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_nameSubstitua
WORKLOAD_NAMESPACEpelo namespace do Kubernetes em que a carga de trabalho é executada.Aplique o manifesto e confirme se o recurso
PodMonitoringfoi criado:kubectl apply -f orbax-grain-podmonitoring.yaml kubectl get podmonitoring -A
Um recurso PodMonitoring lê pods apenas no próprio namespace. Se as
cargas de trabalho forem executadas em vários namespaces, use a mesma especificação com kind:
ClusterPodMonitoring e omita o campo metadata.namespace. Um recurso ClusterPodMonitoring descobre pods correspondentes em todos os namespaces.
Opcional: verifique se o Google Cloud Managed Service para Prometheus está coletando os pods
Para verificar se o Google Cloud Managed Service para Prometheus está coletando ativamente os pods de carga de trabalho, siga estas etapas:
- No namespace
gmp-public, edite o recursoOperatorConfige definafeatures.targetStatus.enabledcomotrue. Inspecione o recurso
PodMonitoringe confirme se os destinos informamHealth: up:kubectl -n NAMESPACE describe podmonitoring/orbax-grain-metricsSubstitua
NAMESPACEpelo namespace do Kubernetes em que sua carga de trabalho é executada.Depois de concluir a solução de problemas, defina
features.targetStatus.enabledde volta comofalseno recursoOperatorConfig. Recomendamos ativar o status de destino apenas quando você estiver investigando problemas ativos.
Consultar as métricas no Cloud Monitoring
Para consultar as métricas enviadas ao Cloud Monitoring, siga estas etapas:
- No console do Google Cloud , acesse Monitoring > Metrics Explorer.
Selecione PromQL e insira a seguinte consulta para confirmar se os destinos estão gerando relatórios:
up{namespace="NAMESPACE"}Substitua
NAMESPACEpelo namespace do Kubernetes da carga de trabalho.
No seletor de métricas baseado em menu, as métricas são armazenadas usando o formato
prometheus.googleapis.com/METRIC_NAME/TYPE, em que TYPE é counter, histogram ou gauge. Cada
biblioteca cria o nome da métrica do Prometheus com base no caminho da métrica, substituindo
/ por _. Os contadores adicionam um sufixo _total, e os histogramas são exportados como
série temporal _bucket, _sum e _count.
Use os exemplos de consultas PromQL a seguir para analisar as métricas do Orbax e do 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])))
Considerações sobre o custo
O faturamento do Google Cloud Managed Service para Prometheus é baseado no número de amostras
ingeridas. Para reduzir custos, configure um interval de raspagem de dados mais longo e use
metricRelabeling para manter apenas as série temporal necessárias. É possível conferir o
volume de ingestão de cada métrica na página Gerenciamento de métricas no
Cloud Monitoring.
Ver as saídas do analisador no Diagnóstico de ML
O monitoramento de carga de trabalho do diagnóstico de ML
e as métricas do sistema contextualizadas de carga de trabalho são ativados automaticamente para
as cargas de trabalho de TPU do GKE JobSet e Job em execução na
versão 1.36.4-gke.1247000 e mais recentes do GKE. O monitoramento de cargas de trabalho
rastreia o ciclo de trabalho agregado da TPU para sua carga de trabalho. No caso de uma queda de 15% ou
mais no ciclo de trabalho (performance degradation), o ML Diagnostics executa
analisadores nas camadas de infraestrutura, orquestrador e framework.
Se a carga de trabalho for executada em várias frações (usando a camada MXLA) ou usar as bibliotecas PyGrain ou Orbax, o ML Diagnostics vai executar os seguintes analisadores de framework para determinar se a degradação do desempenho foi causada por latência de transferência de rede, carregamento de dados ou checkpoint assíncrono:
- Analisador de latência de transferência de rede em megascala
- Analisador do PyGrain
- Analisador de checkpoint assíncrono do Orbax
Os relatórios do analisador de diagnósticos de ML são fornecidos sem custo financeiro adicional, e a geração de resultados do analisador não requer a configuração do Google Cloud Managed Service para Prometheus para métricas do Orbax e do PyGrain. Na guia Métricas do sistema do console do ML Diagnostics Google Cloud , as métricas do Megascale aparecem automaticamente quando você usa versões compatíveis do LibTPU e do GKE.
É possível conferir as saídas do analisador de uma das seguintes maneiras:
- Console doGoogle Cloud : no console do ML Diagnostics Google Cloud
(consulte Ver execuções de machine learning), abra
a guia Visão geral do monitoramento, encontre o evento
performance degradatione clique em Ver detalhes para inspecionar o relatório do analisador. - Google Cloud CLI ou API REST: use os comandos
monitored-eventspara listar e descrever eventos e os relatórios do analisador. Para mais informações, consulte Começar a usar a CLI de diagnóstico de ML.