Monitora le metriche del framework del workload

Questo documento spiega come raccogliere e visualizzare le metriche Megascale XLA (MXLA), Orbax e PyGrain (Grain) per i workload Cloud TPU in esecuzione su Google Kubernetes Engine (GKE) e come visualizzare gli analizzatori basati su queste metriche nella piattaforma di diagnostica ML. Monitorando queste metriche, puoi identificare e risolvere i colli di bottiglia delle prestazioni nella comunicazione multislice, nel checkpointing e nel caricamento dei dati.

Ogni insieme di metriche ha come target un componente distinto del tuo workload per aiutarti a diagnosticare i problemi in diverse fasi della pipeline:

  • Metriche Megascale XLA (MXLA): misura le latenze di trasferimento della rete del data center (DCN) tra slice, i tempi di trasferimento da dispositivo a host (D2H) e da host a dispositivo (H2D), la latenza di calcolo e le operazioni collettive end-to-end nei workload TPU multislice. Utilizza queste metriche per identificare i ritardatari e i colli di bottiglia dell'hardware.
  • Metriche Orbax: monitora la durata dei salvataggi e dei ripristini dei checkpoint asincroni, il volume dei dati e il throughput di scrittura dalla libreria di checkpoint Orbax. Utilizza queste metriche per rilevare ritardi, blocchi o tempi di blocco eccessivi dei thread di addestramento durante il checkpointing.
  • Metriche PyGrain (Grain): misurano la latenza di iterazione del set di dati, i tempi di lettura dell'origine dati, i byte totali letti e l'idoneità del buffer di precaricamento dalla libreria di caricamento dei dati PyGrain. Utilizza queste metriche per determinare se il workload è limitato dall'input a causa di colli di bottiglia di I/O o di caricamento dei dati.

Puoi accedere a queste metriche tramite una porta Prometheus che leggi direttamente, la libreria di monitoraggio TPU, l'interfaccia a riga di comando tpu-info o Cloud Monitoring.

La piattaforma ML Diagnostics include anche analizzatori del monitoraggio dei workload che analizzano automaticamente queste metriche quando un workload subisce un peggioramento delle prestazioni. Questi analizzatori determinano se un calo del ciclo di lavoro della TPU è causato dalla latenza di trasferimento di rete MXLA, dal checkpoint asincrono di Orbax o dal caricamento dei dati di PyGrain.

Metriche Megascale

Megascale XLA (MXLA) è un runtime di comunicazione e un'estensione del compilatore che coordina le operazioni collettive su più sezioni TPU sulla rete di data center (DCN). Mentre i link Inter-Chip Interconnect (ICI) gestiscono la comunicazione ad alta velocità tra i chip TPU all'interno di una singola sezione, MXLA gestisce i trasferimenti di dati tra le sezioni, le riduzioni lato host e lo spostamento dei dati tra la memoria host e la memoria ad alta larghezza di banda (HBM) della TPU.

Quando esegui workload multislice sulle TPU, puoi raccogliere metriche MXLA per risolvere i problemi relativi ai colli di bottiglia della rete cross-slice e dell'elaborazione dell'host. GKE raccoglie queste metriche per impostazione predefinita come metriche di sistema GKE, che puoi visualizzare in Cloud Monitoring. Le metriche sono inoltre disponibili automaticamente nella scheda delle metriche di sistema di ML Diagnostics, dove vengono aggregate automaticamente per il contesto del workload di esecuzione ML.

La tabella seguente elenca le metriche Megascale disponibili:

Nome metrica Nome della metrica GKE Descrizione
Latenza di trasferimento DCN MXLA container/multislice/network/dcn_transfer_latencies

Misura la latenza di trasferimento di andata e ritorno della rete del data center (DCN) per ogni blocco di dati. Gli outlier possono essere correlati a un hardware di rete difettoso.

La metrica ha le seguenti proprietà:

  • Tipo di metrica: CUMULATIVE
  • Tipo di valore: DISTRIBUTION
  • Unità: microsecondi (us)
Latenza di trasferimento in entrata MXLA container/multislice/network/dcn_inbound_transfer_latencies

Misura la latenza di trasferimento DCN in entrata unidirezionale per ogni blocco di dati. Gli outlier possono essere correlati a un hardware di rete difettoso.

La metrica ha le seguenti proprietà:

  • Tipo di metrica: CUMULATIVE
  • Tipo di valore: DISTRIBUTION
  • Unità: microsecondi (us)
Latenza di calcolo MXLA container/multislice/accelerator/compute_latencies

Misura la latenza di calcolo dell'host necessaria per completare un'operazione di riduzione. I valori anomali possono indicare problemi di CPU o memoria, ad esempio errori del modulo di memoria dual in-line (DIMM).

La metrica ha le seguenti proprietà:

  • Tipo di metrica: CUMULATIVE
  • Tipo di valore: DISTRIBUTION
  • Unità: microsecondi (us)
Latenza collettiva MXLA e2e container/multislice/network/collective_end_to_end_latencies

Misura la latenza collettiva end-to-end sulla DCN, dal momento in cui l'host avvia l'operazione al momento in cui tutti i peer ricevono l'output. Include la riduzione dei dati lato host e l'invio dell'output alla TPU. I risultati sono stringhe che descrivono in dettaglio la dimensione del buffer, il tipo di operazione e le latenze media, P50, P90, P95 e P99.9.

La metrica ha le seguenti proprietà:

  • Tipo di metrica: CUMULATIVE
  • Tipo di valore: DISTRIBUTION
  • Unità: microsecondi (us)
Latenza d2h MXLA container/multislice/accelerator/device_to_host_transfer_latencies

Misura la latenza di trasferimento unidirezionale da dispositivo a host (D2H) per ogni blocco di dati. Gli outlier possono essere correlati a un hardware di rete difettoso.

La metrica ha le seguenti proprietà:

  • Tipo di metrica: CUMULATIVE
  • Tipo di valore: DISTRIBUTION
  • Unità: microsecondi (us)
Latenza h2d MXLA container/multislice/accelerator/host_to_device_transfer_latencies

Misura la latenza di trasferimento unidirezionale da host a dispositivo (H2D) per ogni blocco di dati. Gli outlier possono essere correlati a un hardware di rete difettoso.

La metrica ha le seguenti proprietà:

  • Tipo di metrica: CUMULATIVE
  • Tipo di valore: DISTRIBUTION
  • Unità: microsecondi (us)

Metriche Orbax

Orbax è una libreria di checkpointing distribuito per i workload JAX che salva e ripristina i pesi del modello, gli stati dell'ottimizzatore e gli iteratori dei set di dati in ambienti single-host e multi-host. Per ridurre al minimo i tempi di inattività dell'addestramento, Orbax supporta il checkpoint asincrono, che copia gli stati dalla memoria della TPU alla memoria dell'host durante la fase sincrona e poi scrive il checkpoint nello spazio di archiviazione in un thread in background mentre l'addestramento continua.

Se il tuo workload utilizza Orbax per il checkpoint, puoi raccogliere le metriche di Orbax per risolvere i problemi relativi a ritardi, throughput di scrittura lento o blocchi del checkpoint. Orbax esporta queste metriche su una porta Prometheus, che puoi leggere direttamente o inviare a Cloud Monitoring utilizzando Google Cloud Managed Service per Prometheus. Per abilitare queste metriche in GKE, Cloud Monitoring o ML Diagnostics, consulta Accedi alle metriche Orbax e PyGrain.

La tabella seguente elenca le metriche Orbax disponibili:

Nome della metrica di Prometheus Descrizione
jax_checkpoint_write_async_total_duration_secs

Tempo totale per l'intera pipeline di scrittura del checkpoint asincrono.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/checkpoint/write/async/total_duration_secs
  • Tipo di metrica: Istogramma
  • Unità: secondi (s)
jax_orbax_write_gbytes

Gigabyte totali scritti durante un'operazione di salvataggio del checkpoint.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/orbax/write/gbytes
  • Tipo di metrica: Istogramma
  • Unità: gigabyte (GBy)
jax_orbax_write_gbytes_per_sec

Velocità effettiva di scrittura in gigabyte al secondo (GBps) sia nelle fasi sincrone che asincrone di un'operazione di salvataggio del checkpoint.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/orbax/write/gbytes_per_sec
  • Tipo di metrica: Istogramma
  • Unità: gigabyte al secondo (GBps)
jax_checkpoint_write_async_blocking_duration_secs

Tempo trascorso nella fase di blocco di un salvataggio asincrono del checkpoint prima del passaggio al thread in background.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/checkpoint/write/async/blocking_duration_secs
  • Tipo di metrica: Istogramma
  • Unità: secondi (s)
jax_orbax_read_total_duration_secs

Durata totale end-to-end di un'operazione di ripristino del checkpoint.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/orbax/read/total_duration_secs
  • Tipo di metrica: Istogramma
  • Unità: secondi (s)
jax_orbax_read_blocking_duration_secs

Durata della fase di preparazione sincrona (bloccante) di un'operazione di ripristino del checkpoint.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/orbax/read/blocking_duration_secs
  • Tipo di metrica: Istogramma
  • Unità: secondi (s)
jax_orbax_write_async_start_total

Numero di operazioni di scrittura di checkpoint asincrone avviate.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /jax/orbax/write/async/start
  • Tipo di metrica: Contatore
  • Unità: conteggio (1)

Metriche PyGrain

PyGrain (Grain) è una libreria Python per la lettura, la pre-elaborazione e l'elaborazione in batch dei dati di input per i workload di addestramento e valutazione del machine learning. PyGrain fornisce pipeline di dati deterministiche e riproducibili che eseguono il precaricamento e la trasformazione dei record sulla CPU host in modo che gli acceleratori TPU non vengano bloccati in attesa dei batch di input.

Se il tuo workload utilizza PyGrain per il caricamento dei dati, puoi raccogliere le metriche di PyGrain per risolvere i problemi relativi ai colli di bottiglia della pipeline di input, alle letture lente dello spazio di archiviazione o ai buffer di precaricamento esauriti. PyGrain esporta queste metriche su una porta Prometheus, che puoi leggere direttamente o inviare a Cloud Monitoring utilizzando Google Cloud Managed Service per Prometheus. Per abilitare queste metriche in GKE, Cloud Monitoring o Diagnostica ML, consulta Accedi alle metriche Orbax e PyGrain.

La tabella seguente elenca le metriche PyGrain disponibili:

Nome della metrica di Prometheus Descrizione
grain_python_dataset_next_duration_ns

Tempo trascorso nella chiamata al metodo next per il set di dati.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /grain/python/dataset/next_duration_ns
  • Tipo di metrica: Istogramma
  • Unità: nanosecondi (ns)
grain_python_dataset_prefetch_buffer_ready_count

Numero di elementi pronti nel buffer di precaricamento.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /grain/python/dataset/prefetch_buffer_ready_count
  • Tipo di metrica: Istogramma
  • Unità: conteggio (1)
grain_python_data_sources_bytes_read_total

Byte totali letti dalle origini dati.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /grain/python/data_sources/bytes_read
  • Tipo di metrica: Contatore
  • Unità: byte (By)
grain_python_dataset_source_read_time_ns

Tempo impiegato per la lettura dall'origine dati.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /grain/python/dataset/source_read_time_ns
  • Tipo di metrica: Istogramma
  • Unità: nanosecondi (ns)
grain_python_data_loader_iterator_get_next

Tempo trascorso nella chiamata al metodo next per la classe DataLoaderIterator.

La metrica ha le seguenti proprietà:

  • Percorso della metrica: /grain/python/data_loader/iterator_get_next
  • Tipo di metrica: Istogramma
  • Unità: nanosecondi (ns)

Prerequisiti

Prima di raccogliere le metriche Megascale, Orbax o PyGrain o di utilizzare gli analizzatori di diagnostica ML associati, assicurati che il tuo ambiente soddisfi i requisiti descritti nelle sezioni seguenti.

Requisiti per la scalabilità su larga scala

Per raccogliere le metriche Megascale e visualizzarle in Cloud Monitoring, devi soddisfare i seguenti requisiti di versione:

  • Installa LibTPU versione 0.40.0 o successive.
  • Per visualizzare queste metriche in Cloud Monitoring, installa GKE versione 1.36.4-gke.1247000 o successive.

Requisiti di Orbax e PyGrain

Per esportare le metriche Orbax e PyGrain dal tuo workload, soddisfa i seguenti requisiti per pacchetti e container:

  • Pacchetti Python:
    • Installa Orbax (orbax-checkpoint) versione 0.12.1 o successive.
    • Installa PyGrain (grain) versione 0.2.18 o successive.
    • Installa il pacchetto Python prometheus-client nell'immagine container. Il pacchetto orbax-checkpoint installa prometheus-client automaticamente come dipendenza, ma grain no. Se il tuo workload utilizza solo PyGrain, installa il pacchetto eseguendo pip install prometheus-client.
  • Configurazione del container del workload:
    • Imposta le seguenti variabili di ambiente:
      • ENABLE_ORBAX_PROMETHEUS_TELEMETRY="true" (attiva le metriche Orbax)
      • ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY="true" (attiva le metriche PyGrain)
    • Esponi la porta TCP 9431 sul container del workload.

La seguente specifica del container di esempio imposta le variabili di ambiente di telemetria ed espone la 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

Sostituisci WORKLOAD_CONTAINER con il nome del container del workload.

Requisiti dell'analizzatore ML Diagnostics

Per utilizzare gli analizzatori di ML Diagnostics per le metriche Megascale, Orbax e PyGrain, installa GKE versione 1.36.4-gke.1247000 o successive.

Accedi alle metriche Megascale

Quando il cluster esegue una versione di GKE e LibTPU supportata, GKE raccoglie automaticamente le metriche di Megascale in modo che tu possa visualizzarle in Cloud Monitoring. Puoi anche eseguire il deployment di un raccoglitore Prometheus di tua scelta per leggere le metriche Megascale direttamente dalla porta Prometheus del runtime MXLA.

Accedi alle metriche Orbax e PyGrain

Quando attivi la telemetria di Prometheus sul container del workload, Orbax e PyGrain esportano le metriche sulla porta TCP 9431. Puoi accedere a queste metriche in uno dei seguenti modi:

  • Leggi direttamente l'endpoint Prometheus: esegui il deployment di un raccoglitore Prometheus di tua scelta per leggere le metriche Orbax e PyGrain dalla porta 9431 sul container del workload.
  • Invia metriche a Cloud Monitoring: utilizza Google Cloud Managed Service per Prometheus per leggere la porta 9431 su ogni nodo e inviare le metriche a Cloud Monitoring.

Visualizza le metriche con Google Cloud Managed Service per Prometheus

Per inviare le metriche Orbax e PyGrain dalla porta 9431 a Cloud Monitoring, esegui il deployment di una risorsa personalizzata PodMonitoring di Google Cloud Managed Service per Prometheus nel tuo cluster GKE. La risorsa PodMonitoring indica al raccoglitore di Google Cloud Managed Service per Prometheus su ogni nodo di leggere la porta 9431 e inviare le metriche a Cloud Monitoring. Per saperne di più, consulta Configura una risorsa PodMonitoring.

L'endpoint prometheus.googleapis.com e l'agente di raccolta di Google Cloud Managed Service per Prometheus sono abilitati per impostazione predefinita nei cluster GKE. L'utilizzo di Google Cloud Managed Service per Prometheus comporta costi aggiuntivi.

Abilita raccolta gestita

La raccolta gestita per Google Cloud Managed Service per Prometheus è abilitata per impostazione predefinita nei cluster GKE Standard che eseguono GKE versione 1.27 o successive. Per saperne di più, consulta Abilita la raccolta gestita.

Se la raccolta gestita è disabilitata sul tuo cluster, attivala:

gcloud container clusters update CLUSTER_NAME \
  --enable-managed-prometheus \
  --region=REGION

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del tuo cluster GKE.
  • REGION: la regione in cui si trova il cluster.

Se hai modificato le autorizzazioni predefinite del account di servizio del nodo, assicurati che disponga del ruolo Monitoring Metric Writer (roles/monitoring.metricWriter).

Configura il template del pod del workload

Per preparare i pod del workload per lo scraping, aggiorna il template del pod nel manifest JobSet, Job o Deployment:

  1. Aggiungi un'etichetta pod, ad esempio ml-framework-metrics: "enabled", in modo che la risorsa PodMonitoring possa selezionare i pod del workload.
  2. Imposta le variabili di ambiente ENABLE_ORBAX_PROMETHEUS_TELEMETRY e ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY su "true".
  3. Esponi la porta TCP 9431 e assegnale un nome, ad esempio framework-metrics.

Il seguente esempio di template di pod configura questi campi:

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

Sostituisci WORKLOAD_CONTAINER con il nome del container del workload.

Verifica l'endpoint delle metriche

Prima di eseguire il deployment della risorsa PodMonitoring, verifica che il container del workload esporti le metriche sulla porta 9431. Inoltra la porta 9431 da un pod del workload in esecuzione ed esegui una query sull'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)'

Sostituisci quanto segue:

  • NAMESPACE: lo spazio dei nomi Kubernetes in cui viene eseguito il workload.
  • WORKLOAD_POD: il nome di un pod del workload in esecuzione.

Orbax inizializza ogni metrica la prima volta che registra un valore, quindi le metriche Orbax vengono visualizzate solo dopo la prima operazione di salvataggio o ripristino del checkpoint.

Esegui il deployment della risorsa PodMonitoring

Per configurare Google Cloud Managed Service per Prometheus in modo che legga i pod del tuo workload, completa i seguenti passaggi:

  1. Salva il seguente manifest come 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
    

    Sostituisci WORKLOAD_NAMESPACE con lo spazio dei nomi Kubernetes in cui viene eseguito il workload.

  2. Applica il manifest e verifica che la risorsa PodMonitoring sia stata creata:

    kubectl apply -f orbax-grain-podmonitoring.yaml
    kubectl get podmonitoring -A
    

Una risorsa PodMonitoring legge i pod solo nel proprio spazio dei nomi. Se i tuoi workload vengono eseguiti in più namespace, utilizza la stessa specifica con kind: ClusterPodMonitoring e ometti il campo metadata.namespace. Una risorsa ClusterPodMonitoring rileva i pod corrispondenti in tutti gli spazi dei nomi.

(Facoltativo) Verifica che Google Cloud Managed Service per Prometheus stia eseguendo lo scraping dei pod

Per verificare che Google Cloud Managed Service per Prometheus stia eseguendo attivamente lo scraping dei pod del workload, completa i seguenti passaggi:

  1. Nello spazio dei nomi gmp-public, modifica la risorsa OperatorConfig e imposta features.targetStatus.enabled su true.
  2. Esamina la risorsa PodMonitoring e verifica che i target segnalino Health: up:

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

    Sostituisci NAMESPACE con lo spazio dei nomi Kubernetes in cui viene eseguito il workload.

  3. Al termine della risoluzione dei problemi, imposta nuovamente features.targetStatus.enabled su false nella risorsa OperatorConfig. L'attivazione dello stato di destinazione è consigliata solo quando stai esaminando problemi attivi.

Esegui query sulle metriche in Cloud Monitoring

Per eseguire query sulle metriche inviate a Cloud Monitoring, completa i seguenti passaggi:

  1. Nella console Google Cloud , vai a Monitoring > Esplora metriche.
  2. Seleziona PromQL, quindi inserisci la seguente query per verificare che i tuoi target generino report:

    up{namespace="NAMESPACE"}
    

    Sostituisci NAMESPACE con lo spazio dei nomi Kubernetes del tuo workload.

Nel selettore delle metriche basato su menu, le metriche vengono archiviate utilizzando il formato prometheus.googleapis.com/METRIC_NAME/TYPE, dove TYPE è counter, histogram o gauge. Ogni libreria crea il nome della metrica Prometheus dal percorso della metrica sostituendo / con _. I contatori aggiungono un suffisso _total e gli istogrammi vengono esportati come serie temporali _bucket, _sum e _count.

Puoi utilizzare le seguenti query PromQL di esempio per analizzare le metriche di Orbax e 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])))

Considerazioni sui costi

La fatturazione di Google Cloud Managed Service per Prometheus si basa sul numero di campioni importati. Per ridurre i costi, configura uno scraping interval più lungo e utilizza metricRelabeling per conservare solo le serie temporali di cui hai bisogno. Puoi visualizzare il volume di importazione per ogni metrica nella pagina Gestione delle metriche in Cloud Monitoring.

Visualizza gli output dell'analizzatore in ML Diagnostics

Il monitoraggio dei workload di diagnostica ML e le metriche di sistema contestualizzate per i workload vengono abilitati automaticamente per i workload TPU GKE JobSet e Job in esecuzione su GKE versione 1.36.4-gke.1247000 e successive. Il monitoraggio dei workload monitora il ciclo di servizio TPU aggregato per il tuo workload. In caso di un calo del ciclo di lavoro (performance degradation) pari o superiore al 15%, ML Diagnostics esegue gli analizzatori nei livelli di infrastruttura, orchestratore e framework.

Se il tuo workload viene eseguito su più sezioni (utilizzando il livello MXLA) o utilizza le librerie PyGrain o Orbax, ML Diagnostics esegue i seguenti analizzatori del framework per determinare se il peggioramento delle prestazioni è stato causato dalla latenza di trasferimento di rete, dal caricamento dei dati o dal checkpoint asincrono:

I report dell'analizzatore di ML Diagnostics vengono forniti senza costi aggiuntivi e la generazione dei risultati dell'analizzatore non richiede la configurazione di Google Cloud Managed Service per Prometheus per le metriche Orbax e PyGrain. Nella scheda Metriche di sistema della console di ML Diagnostics Google Cloud , le metriche di Megascale vengono visualizzate automaticamente quando utilizzi le versioni supportate di LibTPU e GKE.

Puoi visualizzare gli output dell'analizzatore in uno dei seguenti modi: