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:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidade: microssegundos (us)
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:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidade: microssegundos (us)
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:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidade: microssegundos (us)
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:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidade: microssegundos (us)
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:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidade: microssegundos (us)
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:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidade: microssegundos (us)

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:

  • Caminho da métrica: /jax/checkpoint/write/async/total_duration_secs
  • Tipo de métrica: histograma
  • Unidade: segundos (s)
jax_orbax_write_gbytes

Total de gigabytes gravados durante uma operação de salvamento de checkpoint.

A métrica tem as seguintes propriedades:

  • Caminho da métrica: /jax/orbax/write/gbytes
  • Tipo de métrica: histograma
  • Unidade: gigabytes (GBy)
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:

  • Caminho da métrica: /jax/orbax/write/gbytes_per_sec
  • Tipo de métrica: histograma
  • Unidade: gigabytes por segundo (GBps)
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:

  • Caminho da métrica: /jax/checkpoint/write/async/blocking_duration_secs
  • Tipo de métrica: histograma
  • Unidade: segundos (s)
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:

  • Caminho da métrica: /jax/orbax/read/total_duration_secs
  • Tipo de métrica: histograma
  • Unidade: segundos (s)
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:

  • Caminho da métrica: /jax/orbax/read/blocking_duration_secs
  • Tipo de métrica: histograma
  • Unidade: segundos (s)
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:

  • Caminho da métrica: /jax/orbax/write/async/start
  • Tipo de métrica: contador
  • Unidade: contagem (1)

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 next para o conjunto de dados.

A métrica tem as seguintes propriedades:

  • Caminho da métrica: /grain/python/dataset/next_duration_ns
  • Tipo de métrica: histograma
  • Unidade: nanossegundos (ns)
grain_python_dataset_prefetch_buffer_ready_count

Número de elementos prontos no buffer de pré-busca.

A métrica tem as seguintes propriedades:

  • Caminho da métrica: /grain/python/dataset/prefetch_buffer_ready_count
  • Tipo de métrica: histograma
  • Unidade: contagem (1)
grain_python_data_sources_bytes_read_total

Total de bytes lidos das fontes de dados.

A métrica tem as seguintes propriedades:

  • Caminho da métrica: /grain/python/data_sources/bytes_read
  • Tipo de métrica: contador
  • Unidade: bytes (By)
grain_python_dataset_source_read_time_ns

Tempo gasto lendo da fonte de dados.

A métrica tem as seguintes propriedades:

  • Caminho da métrica: /grain/python/dataset/source_read_time_ns
  • Tipo de métrica: histograma
  • Unidade: nanossegundos (ns)
grain_python_data_loader_iterator_get_next

Tempo gasto na chamada de método next para a classe DataLoaderIterator.

A métrica tem as seguintes propriedades:

  • Caminho da métrica: /grain/python/data_loader/iterator_get_next
  • Tipo de métrica: histograma
  • Unidade: nanossegundos (ns)

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.0 ou mais recente da LibTPU.
  • Para conferir essas métricas no Cloud Monitoring, instale a versão 1.36.4-gke.1247000 ou 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ão 0.12.1 ou mais recente.
    • Instale o PyGrain (grain) versão 0.2.18 ou mais recente.
    • Instale o pacote Python prometheus-client na imagem do contêiner. O pacote orbax-checkpoint instala prometheus-client automaticamente como uma dependência, mas o grain não. Se a carga de trabalho usar apenas o PyGrain, instale o pacote executando pip install prometheus-client.
  • 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 9431 no contêiner da carga de trabalho.

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 9431 no 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 9431 em 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:

  1. Adicione um rótulo de pod, como ml-framework-metrics: "enabled", para que o recurso PodMonitoring possa selecionar os pods de carga de trabalho.
  2. Defina as variáveis de ambiente ENABLE_ORBAX_PROMETHEUS_TELEMETRY e ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY como "true".
  3. Exponha a porta TCP 9431 e atribua um nome a ela, como framework-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:

  1. 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_name
    

    Substitua WORKLOAD_NAMESPACE pelo namespace do Kubernetes em que a carga de trabalho é executada.

  2. Aplique o manifesto e confirme se o recurso PodMonitoring foi 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:

  1. No namespace gmp-public, edite o recurso OperatorConfig e defina features.targetStatus.enabled como true.
  2. Inspecione o recurso PodMonitoring e confirme se os destinos informam Health: up:

    kubectl -n NAMESPACE describe podmonitoring/orbax-grain-metrics
    

    Substitua NAMESPACE pelo namespace do Kubernetes em que sua carga de trabalho é executada.

  3. Depois de concluir a solução de problemas, defina features.targetStatus.enabled de volta como false no recurso OperatorConfig. 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:

  1. No console do Google Cloud , acesse Monitoring > Metrics Explorer.
  2. Selecione PromQL e insira a seguinte consulta para confirmar se os destinos estão gerando relatórios:

    up{namespace="NAMESPACE"}
    

    Substitua NAMESPACE pelo 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:

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 degradation e clique em Ver detalhes para inspecionar o relatório do analisador.
  • Google Cloud CLI ou API REST: use os comandos monitored-events para 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.