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:
|
| 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:
|
| 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:
|
| 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:
|
| 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:
|
| 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:
|
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:
|
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:
|
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:
|
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:
|
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:
|
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:
|
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:
|
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 La métrica tiene las siguientes propiedades:
|
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:
|
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:
|
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:
|
grain_python_data_loader_iterator_get_next |
Es el tiempo que se dedica a la llamada de método La métrica tiene las siguientes propiedades:
|
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.0o una posterior de LibTPU. - Para ver estas métricas en Cloud Monitoring, instala la versión
1.36.4-gke.1247000de 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.1o una posterior de Orbax (orbax-checkpoint). - Instala la versión
0.2.18o una posterior de PyGrain (grain). - Instala el paquete de Python
prometheus-clienten tu imagen de contenedor. El paqueteorbax-checkpointinstalaprometheus-clientautomáticamente como una dependencia, perograinno lo hace. Si tu carga de trabajo solo usa PyGrain, instala el paquete ejecutandopip install prometheus-client.
- Instala la versión
- 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
9431en el contenedor de la carga de trabajo.
- Configura las siguientes variables de entorno:
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
9431en 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
9431en 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:
- Agrega una etiqueta de Pod, como
ml-framework-metrics: "enabled", para que el recursoPodMonitoringpueda seleccionar los Pods de la carga de trabajo. - Establece las variables de entorno
ENABLE_ORBAX_PROMETHEUS_TELEMETRYyENABLE_PYGRAIN_PROMETHEUS_TELEMETRYen"true". - Expón el puerto TCP
9431y asígnale un nombre de puerto, comoframework-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:
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_nameReemplaza
WORKLOAD_NAMESPACEpor el espacio de nombres de Kubernetes en el que se ejecuta tu carga de trabajo.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:
- En el espacio de nombres
gmp-public, edita el recursoOperatorConfigy establecefeatures.targetStatus.enabledentrue. Inspecciona el recurso
PodMonitoringy confirma que los destinos informenHealth: up:kubectl -n NAMESPACE describe podmonitoring/orbax-grain-metricsReemplaza
NAMESPACEpor el espacio de nombres de Kubernetes en el que se ejecuta tu carga de trabajo.Cuando termines de solucionar los problemas, vuelve a establecer
features.targetStatus.enabledenfalseen el recursoOperatorConfig. 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:
- En la consola de Google Cloud , ve a Monitoring > Explorador de métricas.
Selecciona PromQL y, luego, ingresa la siguiente consulta para confirmar que tus destinos informan:
up{namespace="NAMESPACE"}Reemplaza
NAMESPACEpor 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:
- Analizador de latencia de transferencia de red a gran escala
- Analizador de PyGrain
- Analizador de puntos de control asíncronos de Orbax
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 degradationy haz clic en Ver detalles para inspeccionar el informe del analizador. - Google Cloud CLI o API de REST: Usa los comandos
monitored-eventspara 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.