Cómo portar cargas de trabajo de JAX a Pathways

Este documento está dirigido a ingenieros de aprendizaje automático que portan cargas de trabajo de JAX a Pathways en Google Kubernetes Engine (GKE). En él, se explica cómo la ejecución de un solo controlador afecta la indexación de dispositivos, el tamaño del host de CPU, la integración de pathwaysutils, la creación de puntos de control, la carga de datos, el almacenamiento en caché de compilación, la generación de perfiles y las marcas de XLA.

Antes de comenzar

Completa los siguientes requisitos previos:

Índice de procesos

JAX con Pathways trata todos los dispositivos de tu clúster de Pathways como locales, lo que simplifica la administración de dispositivos y permite que JAX use todos los recursos disponibles. En la práctica, esto significa lo siguiente:

  • jax.process_index() siempre devuelve 0 para todos los dispositivos.
  • jax.devices() y jax.local_devices() devuelven todos los dispositivos de Cloud TPU en todo el trabajo.

Tipo de hardware y coubicación

Para obtener el mejor rendimiento, coloca todos los componentes de Pathways y tu trabajo de JAX en la misma zona deGoogle Cloud . Ejecuta los componentes del nodo principal de la CPU, como el servidor proxy de IFRT, el administrador de recursos de Pathways y (para las cargas de trabajo por lotes) el proceso del controlador de JAX, en una VM de CPU dedicada de alta capacidad para controlar la sobrecarga de compilación y coordinación. Usa al menos un tipo de máquina n2-standard-64, que proporciona 64 CPU virtuales y 256 GB de memoria.

El paquete pathwaysutils

Pathways-utils es un paquete de Python de código abierto que integra las cargas de trabajo de JAX con Pathways en Cloud. Proporciona las siguientes funciones para ayudarte a enfocarte en tus flujos de trabajo de aprendizaje automático con cambios mínimos en la configuración:

  • Proxy JAX backend: Habilita el backend de Pathways cuando configuras la variable de entorno JAX_PLATFORMS=proxy.
  • Utilidades de generación de perfiles integradas: Te permiten generar perfiles de tu código de JAX y los componentes de Pathways subyacentes con las APIs de generación de perfiles de JAX estándar, como jax.profiler.start_trace y jax.profiler.start_server.
  • Puntos de control distribuidos con Orbax: Registra controladores de puntos de control de Orbax personalizados cuando importas pathwaysutils, lo que te permite guardar y restablecer puntos de control distribuidos sin cambiar tu código de Orbax.
  • Primitivas de entrenamiento elástico: Proporcionan componentes básicos para el entrenamiento elástico, de modo que tus trabajos de entrenamiento puedan adaptarse de forma dinámica a los cambios en las porciones de Cloud TPU disponibles.

Creación de puntos de control

Orbax se prueba con Pathways para la creación de puntos de control y el restablecimiento distribuidos con Cloud Storage. Cuando configuras la variable de entorno ENABLE_PATHWAYS_PERSISTENCE=1 y llamas a import pathwaysutils; pathwaysutils.initialize() en tu secuencia de comandos de entrenamiento, Pathways registra un ArrayHandler personalizado. Ejecuta operaciones de puntos de control a través del proxy Interim Framework Runtime (IFRT), lo que permite que los trabajadores de Pathways en aceleradores guarden y restablezcan datos directamente.

Python ubicado en el mismo lugar

Python ubicado en el mismo lugar es una API de JAX de código abierto que te permite ejecutar código de Python especificado por el usuario directamente en las CPUs de host conectadas a los aceleradores. En GKE, Pathways ejecuta Python ubicado en el mismo lugar en las VMs de trabajador de Cloud TPU para evitar transferir datos del host a través del controlador para la carga de datos y la creación de puntos de control.

Para compilar una imagen de contenedor sidecar personalizada y configurar tu Pathways JobSet con memoria de host compartida sin copia, consulta Ejecuta Python ubicado en el mismo lugar con Pathways.

Carga de datos

Durante el entrenamiento, tu carga de trabajo carga lotes de un conjunto de datos de forma repetida para introducirlos en el modelo. Usar un cargador de datos asíncrono y eficiente que divida cada lote en fragmentos entre los hosts evita que los aceleradores se queden sin trabajo. En el entrenamiento estándar de Pathways, el cargador de datos se ejecuta en una VM de CPU (en lugar de en VMs de trabajador de Cloud TPU, como en las configuraciones de varios controladores) y envía datos a las VMs de Cloud TPU. La lectura en la red agrega latencia, que Pathways mitiga parcialmente leyendo con anticipación varios lotes en el host de la CPU y enviando los datos de forma asíncrona a las Cloud TPU. Este enfoque es suficiente para una escala pequeña o mediana.

Cuando ejecutas un cargador de datos de varios procesos (como Grain) en el contenedor de carga de trabajo principal en GKE, el contenedor comparte el nodo principal con los contenedores pathways-proxy y pathways-rm. Debido a este host compartido, configura lo siguiente:

  • Establece un recuento de trabajadores explícito: Dentro de un contenedor, os.cpu_count() informa las CPU virtuales totales de la VM host, en lugar del límite de CPU del contenedor. Pasa un recuento de trabajadores explícito (no más que el límite de CPU del contenedor) en lugar de derivarlo de os.cpu_count().
  • Activa un volumen /dev/shm respaldado por memoria: Los cargadores de datos de varios procesos usan la memoria compartida de POSIX (/dev/shm) para la comunicación entre procesos. Activa un volumen emptyDir (medium: Memory) respaldado por memoria en /dev/shm para que los lotes recuperados previamente no superen el límite predeterminado de memoria compartida del contenedor.

Para obtener un rendimiento óptimo a gran escala, coloca tu canalización de datos de entrada con Python colocado para que se ejecute directamente en los hosts de trabajadores de Cloud TPU. Esto elimina el cuello de botella de la CPU y usa las interconexiones de Cloud TPU para una transferencia de datos rápida.

Para ver un ejemplo de referencia de la migración de una canalización de entrada basada en TFDS, consulta la implementación de RemoteIterator en multihost_dataloading.py. Esta implementación funciona tanto en JAX como en Pathways de varios controladores con la API de JAX de Python ubicada en el mismo lugar.

Control de versiones de JAX

Las versiones de Pathways están estrechamente vinculadas con las versiones de JAX para garantizar la compatibilidad y la estabilidad. Verifica que las imágenes de contenedor de Pathways y tu versión de JAX estén alineadas. Cada versión de Pathways especifica su versión de JAX compatible a través de una etiqueta de imagen con el formato jax-<version>.

Caché de compilación

La caché de compilación persistente de Pathways almacena los ejecutables de XLA compilados en una ubicación persistente, como Cloud Storage, para evitar la compilación redundante. Esta función está habilitada de forma predeterminada cuando pasas --gcs_scratch_location a los contenedores pathways-proxy, pathways-rm y pathways-worker (o worker). Para mantener bajos los costos de almacenamiento, la caché asocia una política de ciclo de vida de los objetos al bucket de Cloud Storage. Debido a que Cloud Storage limita los buckets a 50 políticas de ciclo de vida, usa una ubicación común de Cloud Storage en todas las cargas de trabajo.

Si omites la marca --gcs_scratch_location o la dejas vacía, Pathways recurre a una caché de compilación en la memoria. Esta caché no conserva los ejecutables de XLA compilados en las implementaciones de Pathways.

Esta caché es similar a la caché de compilación de JAX, que pathwaysutils.initialize() inhabilita para las cargas de trabajo de Pathways.

La caché de compilación requiere los siguientes permisos de Cloud Storage:

  • storage.buckets.get: Recupera los metadatos del bucket.
  • storage.buckets.update: Permite que Pathways configure políticas de ciclo de vida de objetos para aplicar de manera forzosa el TTL para la expulsión de la caché.
  • storage.objects.list: Enumera los objetos de caché existentes dentro del bucket.
  • storage.objects.create: Escribe nuevos ejecutables compilados en la caché.
  • storage.objects.get: Lee los ejecutables almacenados en caché del bucket.

Genera perfiles

Puedes usar el generador de perfiles de JAX para generar seguimientos de un programa de JAX de dos maneras:

  • Programática: Captura perfiles directamente desde tu código de JAX.
  • Manual: Captura perfiles a pedido después de iniciar el servidor del generador de perfiles en tu código de JAX.

En ambos casos, Pathways escribe los perfiles en un bucket de Cloud Storage y crea varios archivos de registro, posiblemente en diferentes directorios con marcas de tiempo, por ejemplo:

  • Es el proceso principal de Python que invocó el seguimiento (por lo general, la VM de tu notebook): JAX_CLIENT_VM_NAME.xplane.pb
  • Proxy de IFRT de Pathways: client.PATHWAYS_HEAD_NODE_NAME.xplane.pb
  • Administrador de recursos de Pathways: server.*PATHWAYS_HEAD_NODE_NAME.xplane.pb
  • Trabajadores de Pathways: server.*TPU_NODE_NAME.xplane.pb

Puedes analizar estos archivos de seguimiento con TensorBoard ejecutando los siguientes comandos. Para obtener más información sobre TensorBoard y sus herramientas de generación de perfiles, consulta Optimiza el rendimiento de TensorFlow con el generador de perfiles.

# Verify that trace files are present
gcloud storage ls -l -r gs://BUCKET/PREFIX

# View on TensorBoard
tensorboard --load_fast=false --logdir=gs://BUCKET/PREFIX

Reemplaza lo siguiente:

  • BUCKET: Es el bucket de Cloud Storage que almacena los archivos de registro.
  • PREFIX: Es la ruta de acceso dentro de tu bucket de Cloud Storage en el que se almacenan los archivos de registro.

Captura de perfiles programática

Captura un perfil desde tu código. Pathways guarda los perfiles en gs://BUCKET/PREFIX en un directorio de marca de tiempo:

import jax
import pathwaysutils

pathwaysutils.initialize()

jax.profiler.start_trace("gs://BUCKET/PREFIX")

# Run the operations to be profiled
key = jax.random.key(0)
x = jax.random.normal(key, (5000, 5000))
y = x @ x
y.block_until_ready()

jax.profiler.stop_trace()

Captura manual de perfiles

Para capturar la información de perfil de forma manual, inicia el servidor del generador de perfiles desde tu código de Python:

import jax
import pathwaysutils

pathwaysutils.initialize()

jax.profiler.start_server(JAX_PROFILER_PORT)

# Your JAX code
jax.profiler.stop_server()

Reemplaza JAX_PROFILER_PORT por el número de puerto del servidor del generador de perfiles de JAX.

Mientras se ejecuta el servidor del generador de perfiles, captura un perfil y exporta los datos a la ubicación de destino de Cloud Storage. Ejecuta el siguiente comando desde el contenedor de la carga de trabajo o después de reenviar JAX_PROFILER_PORT desde el Pod pathways-head:

export DURATION_IN_SECS=6
export OUTPUT_DIR="gs://BUCKET/PREFIX/"

curl -X POST http://localhost:JAX_PROFILER_PORT/profiling \
     -H "Content-Type: application/json" \
     -d "{\"duration_ms\": $((DURATION_IN_SECS * 1000)), \"repository_path\": \"${OUTPUT_DIR}\"}"

Puedes encontrar información de tiempo para los métodos de cliente proxy de IFRT, como Compile y Execute, en el seguimiento de tu programa. Estos eventos, que detallan las interacciones con el servidor de gRPC del proxy de IFRT durante la compilación y la ejecución, aparecen en el subproceso llamado GrpcClientSessionUserFuturesWorkQueue. Examinar este subproceso en tu registro te brinda información sobre el rendimiento de estas operaciones.

Marcas de XLA

Cuando uses Pathways, configura las marcas de XLA en el contenedor pathways-proxy.

Cuando uses Cluster Toolkit (el comando gcluster job submit), establece las marcas de XLA con --pathways-proxy-args:

--pathways-proxy-args="--xla_flag_1=value1 --xla_flag_2=value2"

Volcado de HLO

Para inspeccionar las entradas del optimizador de alto nivel (HLO) que se pasan al compilador de XLA, configura Pathways para que vuelque el HLO en una ubicación de Cloud Storage con --pathways-proxy-args:

--pathways-proxy-args="--xla_dump_to=gs://BUCKET_NAME/HLO_PREFIX/"

Reemplaza lo siguiente:

  • BUCKET_NAME: Es el bucket de Cloud Storage para el volcado de HLO.
  • HLO_PREFIX: Es el prefijo de la ruta de acceso dentro de tu bucket.

¿Qué sigue?