Supervisa las métricas del framework de cargas de trabajo

En este documento, se explica cómo recopilar y ver las métricas de Megascale XLA (MXLA), Orbax y PyGrain (Grain) para las cargas de trabajo de Cloud TPU que se ejecutan en Google Kubernetes Engine (GKE), y cómo ver los analizadores creados sobre estas métricas en la plataforma de diagnóstico de AA. Si supervisas estas métricas, puedes identificar y solucionar los cuellos de botella de rendimiento en la comunicación de varios sectores, la creación de puntos de control y la carga de datos.

Cada conjunto de métricas se orienta a un componente distinto de tu carga de trabajo para ayudarte a diagnosticar problemas en diferentes etapas de tu canalización:

  • Métricas de Megascale XLA (MXLA): Mide las latencias de transferencia de la red del centro de datos (DCN) entre porciones, los tiempos de transferencia de dispositivo a host (D2H) y de host a dispositivo (H2D), la latencia de procesamiento y las operaciones colectivas de extremo a extremo en las cargas de trabajo de TPU de varias porciones. Usa estas métricas para identificar los rezagados y los cuellos de botella de hardware.
  • Métricas de Orbax: Realiza un seguimiento de las duraciones de guardado y restablecimiento de puntos de control asíncronos, el volumen de datos y la capacidad de procesamiento de escritura de la biblioteca de puntos de control de Orbax. Usa estas métricas para detectar retrasos en los puntos de control, detenciones o un tiempo excesivo de bloqueo de los subprocesos de entrenamiento.
  • Métricas de PyGrain (Grain): Mide la latencia de iteración del conjunto de datos, los tiempos de lectura de la fuente de datos, el total de bytes leídos y la preparación del búfer de carga previa de la biblioteca de carga de datos de PyGrain. Usa estas métricas para determinar si tu carga de trabajo está vinculada a la entrada debido a cuellos de botella de E/S o de carga de datos.

Puedes acceder a estas métricas a través de un puerto de Prometheus que leas directamente, la biblioteca de supervisión de TPU, la CLI de tpu-info o Cloud Monitoring.

La plataforma de ML Diagnostics también incluye analizadores de supervisión de cargas de trabajo que analizan automáticamente estas métricas cuando una carga de trabajo experimenta una degradación del rendimiento. Estos analizadores determinan si una disminución en el ciclo de trabajo de la TPU se debe a la latencia de transferencia de red de MXLA, la creación de puntos de control asíncronos de Orbax o la carga de datos de PyGrain.

Métricas de Megascale

Megascale XLA (MXLA) es un entorno de ejecución de comunicación y una extensión del compilador que coordina las operaciones colectivas en varias porciones de TPU a través de la red del centro de datos (DCN). Mientras que los vínculos de interconexión entre chips (ICI) controlan la comunicación de alta velocidad entre los chips TPU dentro de una sola porción, MXLA administra las transferencias de datos entre porciones, las reducciones del lado del host y el movimiento de datos entre la memoria del host y la memoria de alto ancho de banda (HBM) de la TPU.

Cuando ejecutas cargas de trabajo de Multislice en TPU, puedes recopilar métricas de MXLA para solucionar problemas de cuellos de botella de procesamiento de hosts y redes entre porciones. GKE recopila estas métricas de forma predeterminada como métricas del sistema de GKE, y puedes verlas en Cloud Monitoring. Las métricas también están disponibles automáticamente en la pestaña de métricas del sistema de ML Diagnostics, en la que se agregan de forma automática para el contexto de la carga de trabajo de ejecución de AA.

En la siguiente tabla, se enumeran las métricas de Megascale disponibles:

Nombre de la métrica Nombre de la métrica de GKE Descripción
Latencia de transferencia de DCN de MXLA container/multislice/network/dcn_transfer_latencies

Mide la latencia de transferencia de ida y vuelta de la red del centro de datos (DCN) para cada fragmento de datos. Los valores atípicos pueden correlacionarse con hardware de red defectuoso.

La métrica tiene las siguientes propiedades:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidad: microsegundos (us)
Latencia de transferencia de entrada de MXLA container/multislice/network/dcn_inbound_transfer_latencies

Mide la latencia de transferencia de DCN de entrada unidireccional para cada fragmento de datos. Los valores atípicos pueden correlacionarse con hardware de red defectuoso.

La métrica tiene las siguientes propiedades:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidad: microsegundos (us)
Latencia de procesamiento de MXLA container/multislice/accelerator/compute_latencies

Mide la latencia de procesamiento del host necesaria para completar una operación de reducción. Los valores atípicos pueden indicar problemas de CPU o memoria, como fallas en el módulo de memoria en línea doble (DIMM).

La métrica tiene las siguientes propiedades:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidad: microsegundos (us)
Latencia colectiva de extremo a extremo de MXLA container/multislice/network/collective_end_to_end_latencies

Mide la latencia colectiva de extremo a extremo en la DCN, desde que el host inicia la operación hasta que todos los pares reciben el resultado. Incluye la reducción de datos del host y el envío de resultados a la TPU. Los resultados son cadenas que detallan el tamaño del búfer, el tipo de operación y las latencias medias, P50, P90, P95 y P99.9.

La métrica tiene las siguientes propiedades:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidad: microsegundos (us)
Latencia de d2h de MXLA container/multislice/accelerator/device_to_host_transfer_latencies

Mide la latencia de transferencia unidireccional de dispositivo a host (D2H) para cada fragmento de datos. Los valores atípicos pueden correlacionarse con hardware de red defectuoso.

La métrica tiene las siguientes propiedades:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidad: microsegundos (us)
Latencia de h2d de MXLA container/multislice/accelerator/host_to_device_transfer_latencies

Mide la latencia de transferencia unidireccional de host a dispositivo (H2D) para cada fragmento de datos. Los valores atípicos pueden correlacionarse con hardware de red defectuoso.

La métrica tiene las siguientes propiedades:

  • Tipo de métrica: CUMULATIVE
  • Tipo de valor: DISTRIBUTION
  • Unidad: microsegundos (us)

Métricas de Orbax

Orbax es una biblioteca de puntos de control distribuida para cargas de trabajo de JAX que guarda y restablece pesos de modelos, estados de optimizadores y iteradores de conjuntos de datos en entornos de host único y de varios hosts. Para minimizar el tiempo de inactividad del entrenamiento, Orbax admite puntos de control asíncronos, que copian los estados de la memoria de la TPU a la memoria del host durante la fase síncrona y, luego, escriben el punto de control en el almacenamiento en un subproceso en segundo plano mientras el entrenamiento continúa.

Si tu carga de trabajo usa Orbax para crear puntos de control, puedes recopilar métricas de Orbax para solucionar problemas de retrasos en los puntos de control, capacidad de procesamiento de escritura lenta o bloqueos. Orbax exporta estas métricas en un puerto de Prometheus, que puedes leer directamente o enviar a Cloud Monitoring con Google Cloud Managed Service para Prometheus. Para habilitar estas métricas en GKE, Cloud Monitoring o ML Diagnostics, consulta Accede a las métricas de Orbax y PyGrain.

En la siguiente tabla, se enumeran las métricas de Orbax disponibles:

Nombre de la métrica de Prometheus Descripción
jax_checkpoint_write_async_total_duration_secs

Es el tiempo total de toda la canalización de escritura de puntos de control asíncronos.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/checkpoint/write/async/total_duration_secs
  • Tipo de métrica: Histograma
  • Unidad: segundos (s)
jax_orbax_write_gbytes

Es la cantidad total de gigabytes escritos durante una operación de guardado de punto de control.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/orbax/write/gbytes
  • Tipo de métrica: Histograma
  • Unidad: gigabytes (GBy)
jax_orbax_write_gbytes_per_sec

Capacidad de procesamiento de escritura en gigabytes por segundo (GBps) en las fases síncronas y asíncronas de una operación de guardado de punto de control.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/orbax/write/gbytes_per_sec
  • Tipo de métrica: Histograma
  • Unidad: gigabytes por segundo (GBps)
jax_checkpoint_write_async_blocking_duration_secs

Es el tiempo que se pasa en la fase de bloqueo de un guardado de punto de control asíncrono antes de pasar al subproceso en segundo plano.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/checkpoint/write/async/blocking_duration_secs
  • Tipo de métrica: Histograma
  • Unidad: segundos (s)
jax_orbax_read_total_duration_secs

Es la duración total de extremo a extremo de una operación de restablecimiento de un punto de control.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/orbax/read/total_duration_secs
  • Tipo de métrica: Histograma
  • Unidad: segundos (s)
jax_orbax_read_blocking_duration_secs

Es la duración de la fase de preparación síncrona (bloqueo) de una operación de restablecimiento de un punto de control.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/orbax/read/blocking_duration_secs
  • Tipo de métrica: Histograma
  • Unidad: segundos (s)
jax_orbax_write_async_start_total

Es el recuento de operaciones de escritura de puntos de control asíncronos que se iniciaron.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /jax/orbax/write/async/start
  • Tipo de métrica: Contador
  • Unidad: recuento (1)

Métricas de PyGrain

PyGrain (Grain) es una biblioteca de Python para leer, procesar previamente y agrupar en lotes los datos de entrada para las cargas de trabajo de entrenamiento y evaluación del aprendizaje automático. PyGrain proporciona canalizaciones de datos deterministas y reproducibles que recuperan previamente y transforman registros en la CPU del host para que los aceleradores de TPU no se detengan mientras esperan los lotes de entrada.

Si tu carga de trabajo usa PyGrain para la carga de datos, puedes recopilar métricas de PyGrain para solucionar problemas de cuellos de botella en la canalización de entrada, lecturas de almacenamiento lentas o búferes de carga previa agotados. PyGrain exporta estas métricas en un puerto de Prometheus, que puedes leer directamente o enviar a Cloud Monitoring con Google Cloud Managed Service para Prometheus. Para habilitar estas métricas en GKE, Cloud Monitoring o Diagnóstico de AA, consulta Accede a las métricas de Orbax y PyGrain.

En la siguiente tabla, se enumeran las métricas de PyGrain disponibles:

Nombre de la métrica de Prometheus Descripción
grain_python_dataset_next_duration_ns

Es el tiempo que se dedicó a la llamada de método next para el conjunto de datos.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /grain/python/dataset/next_duration_ns
  • Tipo de métrica: Histograma
  • Unidad: nanosegundos (ns)
grain_python_dataset_prefetch_buffer_ready_count

Es la cantidad de elementos listos en el búfer de carga previa.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /grain/python/dataset/prefetch_buffer_ready_count
  • Tipo de métrica: Histograma
  • Unidad: recuento (1)
grain_python_data_sources_bytes_read_total

Es el total de bytes leídos de las fuentes de datos.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /grain/python/data_sources/bytes_read
  • Tipo de métrica: Contador
  • Unidad: bytes (By)
grain_python_dataset_source_read_time_ns

Es el tiempo que se dedica a leer desde la fuente de datos.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /grain/python/dataset/source_read_time_ns
  • Tipo de métrica: Histograma
  • Unidad: nanosegundos (ns)
grain_python_data_loader_iterator_get_next

Es el tiempo que se dedica a la llamada de método next para la clase DataLoaderIterator.

La métrica tiene las siguientes propiedades:

  • Ruta de la métrica: /grain/python/data_loader/iterator_get_next
  • Tipo de métrica: Histograma
  • Unidad: nanosegundos (ns)

Requisitos previos

Antes de recopilar métricas de Megascale, Orbax o PyGrain, o de usar los analizadores de ML Diagnostics asociados, asegúrate de que tu entorno cumpla con los requisitos de las siguientes secciones.

Requisitos de megascale

Para recopilar métricas de Megascale y verlas en Cloud Monitoring, cumple con los siguientes requisitos de versión:

  • Instala la versión 0.40.0 o una posterior de LibTPU.
  • Para ver estas métricas en Cloud Monitoring, instala la versión 1.36.4-gke.1247000 de GKE o una posterior.

Requisitos de Orbax y PyGrain

Para exportar métricas de Orbax y PyGrain desde tu carga de trabajo, cumple con los siguientes requisitos de paquetes y contenedores:

  • Paquetes de Python:
    • Instala la versión 0.12.1 o una posterior de Orbax (orbax-checkpoint).
    • Instala la versión 0.2.18 o una posterior de PyGrain (grain).
    • Instala el paquete de Python prometheus-client en tu imagen de contenedor. El paquete orbax-checkpoint instala prometheus-client automáticamente como una dependencia, pero grain no lo hace. Si tu carga de trabajo solo usa PyGrain, instala el paquete ejecutando pip install prometheus-client.
  • Configuración del contenedor de la carga de trabajo:
    • Configura las siguientes variables de entorno:
      • ENABLE_ORBAX_PROMETHEUS_TELEMETRY="true" (habilita las métricas de Orbax)
      • ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY="true" (habilita las métricas de PyGrain)
    • Expón el puerto TCP 9431 en el contenedor de la carga de trabajo.

En la siguiente especificación de contenedor de ejemplo, se configuran las variables de entorno de telemetría y se expone el puerto 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

Reemplaza WORKLOAD_CONTAINER por el nombre del contenedor de tu carga de trabajo.

Requisitos del analizador de ML Diagnostics

Para usar los analizadores de diagnóstico de ML para las métricas de Megascale, Orbax y PyGrain, instala la versión 1.36.4-gke.1247000 o posterior de GKE.

Accede a las métricas de Megascale

Cuando tu clúster ejecuta una versión de GKE y LibTPU compatibles, GKE recopila automáticamente las métricas de Megascale para que puedas verlas en Cloud Monitoring. También puedes implementar un recopilador de Prometheus que elijas para leer las métricas de Megascale directamente desde el puerto de Prometheus del entorno de ejecución de MXLA.

Accede a las métricas de Orbax y PyGrain

Cuando habilitas la telemetría de Prometheus en tu contenedor de carga de trabajo, Orbax y PyGrain exportan métricas en el puerto TCP 9431. Puedes acceder a estas métricas de cualquiera de las siguientes maneras:

  • Lee el extremo de Prometheus directamente: Implementa un recopilador de Prometheus de tu elección para leer las métricas de Orbax y PyGrain desde el puerto 9431 en el contenedor de la carga de trabajo.
  • Envía métricas a Cloud Monitoring: Usa Google Cloud Managed Service para Prometheus para leer el puerto 9431 en cada nodo y enviar las métricas a Cloud Monitoring.

Visualiza métricas con Google Cloud Managed Service para Prometheus

Para enviar métricas de Orbax y PyGrain desde el puerto 9431 a Cloud Monitoring, implementa un recurso personalizado de Google Cloud Managed Service para Prometheus PodMonitoring en tu clúster de GKE. El recurso PodMonitoring indica al recopilador de Google Cloud Managed Service para Prometheus en cada nodo que lea el puerto 9431 y envíe las métricas a Cloud Monitoring. Para obtener más información, consulta Configura un recurso PodMonitoring.

El extremo prometheus.googleapis.com y el recolector de Google Cloud Managed Service para Prometheus están habilitados de forma predeterminada en los clústeres de GKE. El uso de Google Cloud Managed Service para Prometheus genera cargos adicionales.

Habilitar la recopilación administrada

La recopilación administrada de Google Cloud Managed Service para Prometheus está habilitada de forma predeterminada en los clústeres de GKE Standard que ejecutan la versión 1.27 o posterior de GKE. Para obtener más información, consulta Habilita la recopilación administrada.

Si la recopilación administrada está inhabilitada en tu clúster, habilítala:

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

Reemplaza lo siguiente:

  • CLUSTER_NAME: Es el nombre del clúster de GKE.
  • REGION: Es la región en la que se encuentra el clúster.

Si modificaste los permisos predeterminados en la cuenta de servicio del nodo, asegúrate de que tenga el rol de escritor de métricas de Monitoring (roles/monitoring.metricWriter).

Configura la plantilla de Pod de carga de trabajo

Para preparar los Pods de tu carga de trabajo para la recopilación, actualiza la plantilla de Pod en tu manifiesto de JobSet, Job o Deployment:

  1. Agrega una etiqueta de Pod, como ml-framework-metrics: "enabled", para que el recurso PodMonitoring pueda seleccionar los Pods de la carga de trabajo.
  2. Establece las variables de entorno ENABLE_ORBAX_PROMETHEUS_TELEMETRY y ENABLE_PYGRAIN_PROMETHEUS_TELEMETRY en "true".
  3. Expón el puerto TCP 9431 y asígnale un nombre de puerto, como framework-metrics.

En el siguiente ejemplo de plantilla de Pod, se configuran estos 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

Reemplaza WORKLOAD_CONTAINER por el nombre del contenedor de tu carga de trabajo.

Verifica el extremo de las métricas

Antes de implementar el recurso PodMonitoring, verifica que el contenedor de tu carga de trabajo exporte métricas en el puerto 9431. Reenvía el puerto 9431 desde un Pod de carga de trabajo en ejecución y consulta el extremo /metrics:

kubectl -n NAMESPACE port-forward pod/WORKLOAD_POD 9431:9431
curl -s localhost:9431/metrics | grep -E '^(jax_orbax|jax_checkpoint|grain_python)'

Reemplaza lo siguiente:

  • NAMESPACE: Es el espacio de nombres de Kubernetes en el que se ejecuta tu carga de trabajo.
  • WORKLOAD_POD: Es el nombre de un Pod de carga de trabajo en ejecución.

Orbax inicializa cada métrica la primera vez que registra un valor, por lo que las métricas de Orbax solo aparecen después de la primera operación de guardado o restablecimiento de un punto de control.

Implementa el recurso PodMonitoring

Para configurar Google Cloud Managed Service para Prometheus de modo que lea los Pods de tu carga de trabajo, completa los siguientes pasos:

  1. Guarda el siguiente manifiesto 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
    

    Reemplaza WORKLOAD_NAMESPACE por el espacio de nombres de Kubernetes en el que se ejecuta tu carga de trabajo.

  2. Aplica el manifiesto y confirma que se haya creado el recurso PodMonitoring:

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

Un recurso PodMonitoring lee Pods solo en su propio espacio de nombres. Si tus cargas de trabajo se ejecutan en varios espacios de nombres, usa la misma especificación con kind: ClusterPodMonitoring y omite el campo metadata.namespace. Un recurso ClusterPodMonitoring descubre Pods que coinciden en todos los espacios de nombres.

Opcional: Verifica que Google Cloud Managed Service para Prometheus esté extrayendo los Pods

Para verificar que Google Cloud Managed Service para Prometheus extraiga de forma activa tus Pods de carga de trabajo, completa los siguientes pasos:

  1. En el espacio de nombres gmp-public, edita el recurso OperatorConfig y establece features.targetStatus.enabled en true.
  2. Inspecciona el recurso PodMonitoring y confirma que los destinos informen Health: up:

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

    Reemplaza NAMESPACE por el espacio de nombres de Kubernetes en el que se ejecuta tu carga de trabajo.

  3. Cuando termines de solucionar los problemas, vuelve a establecer features.targetStatus.enabled en false en el recurso OperatorConfig. Se recomienda habilitar el estado de destino solo cuando investigues problemas activos.

Consulta las métricas en Cloud Monitoring

Para consultar las métricas enviadas a Cloud Monitoring, completa los siguientes pasos:

  1. En la consola de Google Cloud , ve a Monitoring > Explorador de métricas.
  2. Selecciona PromQL y, luego, ingresa la siguiente consulta para confirmar que tus destinos informan:

    up{namespace="NAMESPACE"}
    

    Reemplaza NAMESPACE por el espacio de nombres de Kubernetes de tu carga de trabajo.

En el selector de métricas basado en menús, las métricas se almacenan con el formato prometheus.googleapis.com/METRIC_NAME/TYPE, en el que TYPE es counter, histogram o gauge. Cada biblioteca construye su nombre de métrica de Prometheus a partir de su ruta de métrica reemplazando / por _. Los contadores agregan un sufijo _total, y los histogramas se exportan como series temporales _bucket, _sum y _count.

Puedes usar las siguientes consultas de PromQL de ejemplo para analizar las métricas de Orbax y 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])))

Consideraciones de costo

La facturación de Google Cloud Managed Service para Prometheus se basa en la cantidad de muestras transferidas. Para reducir los costos, configura un interval de extracción más largo y usa metricRelabeling para conservar solo las series temporales que necesitas. Puedes ver el volumen de transferencia de cada métrica en la página Administración de métricas en Cloud Monitoring.

Consulta los resultados del analizador en Diagnóstico de AA

La supervisión de cargas de trabajo de ML Diagnostics y las métricas del sistema contextualizadas en la carga de trabajo se habilitan automáticamente para las cargas de trabajo de TPU de GKE JobSet y Job que se ejecutan en la versión 1.36.4-gke.1247000 y posteriores de GKE. La supervisión de cargas de trabajo realiza un seguimiento del ciclo de trabajo de TPU agregado para tu carga de trabajo. En caso de que se produzca una caída del 15% o más en el ciclo de trabajo (performance degradation), el Diagnóstico de ML ejecuta analizadores en las capas de infraestructura, organización y framework.

Si tu carga de trabajo se ejecuta en varios sectores (con la capa de MXLA) o usa las bibliotecas de PyGrain o Orbax, el Diagnóstico de AA ejecuta los siguientes analizadores de framework para determinar si la degradación del rendimiento se debió a la latencia de transferencia de red, la carga de datos o la creación de puntos de control asíncronos:

Los informes del analizador de ML Diagnostics se proporcionan sin cargo adicional, y la generación de resultados del analizador no requiere configurar Google Cloud Managed Service para Prometheus para las métricas de Orbax y PyGrain. En la pestaña Métricas del sistema de la consola de ML Diagnostics Google Cloud , las métricas de Megascale aparecen automáticamente cuando usas las versiones compatibles de LibTPU y GKE.

Puedes ver los resultados del analizador de cualquiera de las siguientes maneras:

  • Consola deGoogle Cloud : En la consola de ML Diagnostics Google Cloud (consulta Visualiza ejecuciones de aprendizaje automático), abre la pestaña Descripción general de la supervisión, busca el evento performance degradation y haz clic en Ver detalles para inspeccionar el informe del analizador.
  • Google Cloud CLI o API de REST: Usa los comandos monitored-events para enumerar y describir los eventos y sus informes de analizador. Para obtener más información, consulta Comienza a usar la CLI de ML Diagnostics.