Introducción a las rutas de aprendizaje en Cloud

Pathways es un entorno de ejecución distribuido para JAX que usa un modelo de ejecución de un solo controlador para organizar cargas de trabajo de aprendizaje automático (AA) a gran escala, de múltiples tareas y activadas de forma dispersa en una o más porciones de TPU. Permite que un solo proceso de Python (el controlador) coordine los cálculos en miles o decenas de miles de chips TPU y asigne de forma dinámica el procesamiento entre las tareas.

En lugar de ejecutar una copia independiente de tu programa de Python en cada VM de TPU, tu carga de trabajo de JAX se ejecuta en un proceso de CPU del cliente (el controlador) y se comunica a través de gRPC con un plano de control de Pathways en un nodo principal de CPU, que es una VM dedicada solo a CPU en tu clúster que aloja los servicios de coordinación y compilación de Pathways. El plano de control compila tu código y envía los cálculos a los trabajadores de Pathways que se ejecutan en tus VMs de TPU.

Google usa Pathways de forma interna para entrenar modelos grandes, como Gemini. Pathways on Cloud lleva la misma arquitectura a los clientes de Google Cloud .

Antes de comenzar

Puedes ejecutar Pathways en Google Kubernetes Engine (GKE) o en un clúster de Cluster Director con Slurm. Selecciona la pestaña de tu plataforma para ver los requisitos previos.

GKE

Completa los siguientes requisitos previos:

En este documento, se supone que ya estás familiarizado con el uso de TPU en GKE, incluidas las TPU de porción única y porciones múltiples en GKE, y que tienes experiencia general con TPU de porciones múltiples.

Para crear un clúster, consulta Crea un clúster de GKE con Pathways.

Cluster Director

Completa los siguientes requisitos previos:

En este documento, se supone que ya conoces Cluster Director, las máquinas de TPU en Cluster Director y la ejecución de trabajos con Slurm, y que tienes experiencia general con las TPU de Multislice.

Para crear un clúster, consulta Crea un clúster de Cluster Director con Pathways.

Controlador único y varios controladores

Las cargas de trabajo de AA distribuidas en las TPU usan un modelo de ejecución de varios controladores (el predeterminado en JAX) o un modelo de ejecución de un solo controlador (usado por Pathways). Los dos modelos difieren en dónde se ejecuta tu código de Python, cómo tu programa ve los aceleradores y cómo se coordinan las cargas de trabajo en las porciones de TPU.

Cargas de trabajo de varios controladores (predeterminada de JAX)

En el modelo de varios controladores, cada VM de TPU en tus porciones de TPU ejecuta la misma secuencia de comandos de Python. Cada VM de TPU actúa como un controlador independiente para los chips TPU conectados directamente a ese host. Las cargas de trabajo de varios controladores tienen las siguientes características:

  • Control distribuido: Cada VM de TPU ejecuta una copia de tu secuencia de comandos de Python en un paso de bloqueo y coordina las operaciones colectivas entre los procesos.
  • Vista de dispositivo localizada: Cada proceso de Python administra directamente solo los chips TPU conectados a su VM local (jax.local_devices()), mientras que jax.devices() enumera todos los dispositivos del clúster.
  • Ejecución de programa único y datos múltiples (SPMD): Debido a que cada host ejecuta la misma secuencia de comandos de forma simultánea, las cargas de trabajo de varios controladores siguen principalmente el paradigma de SPMD. La organización de diferentes operaciones en distintos subconjuntos de porciones de TPU requiere una lógica de coordinación de varios hosts personalizada.
  • Ciclo de vida acoplado al host: Debido a que los controladores de Python se ejecutan directamente en las VMs de TPU, si alguna VM de TPU se interrumpe o falla, todos los procesos del controlador deben detenerse y reiniciarse juntos.

Cargas de trabajo de un solo controlador (Pathways)

En el modelo de controlador único de Pathways, un solo proceso de Python actúa como el controlador central de toda tu carga de trabajo. Tu programa de JAX (el controlador) se ejecuta en un host de CPU, como un contenedor por lotes en un nodo principal de CPU o una VM de cliente externa, y se comunica con el entorno de ejecución de Pathways a través de gRPC en lugar de ejecutarse directamente en tus VMs de TPU. Las cargas de trabajo de un solo controlador tienen las siguientes características:

  • Control centralizado: Ejecutas y supervisas un proceso de controlador de Python que envía cálculos al entorno de ejecución de Pathways, que administra la ejecución en todas las VMs de TPU.
  • Vista unificada de dispositivos: Tu programa de JAX ve todas las porciones de TPU como un solo sistema unificado. En tu código, jax.process_index() siempre es 0, y tanto jax.devices() como jax.local_devices() devuelven cada chip TPU en todas las porciones asignadas como si estuvieran conectados a una máquina grande.
  • Patrones de procesamiento flexibles: Además del entrenamiento de SPMD estándar, un solo controlador puede programar diferentes procesamientos en distintos subconjuntos de aceleradores, lo que admite el paralelismo de canalización asimétrico, las cargas de trabajo de varias tareas y la dispersión computacional.
  • Ciclo de vida del controlador desacoplado: Debido a que tu programa de Python se ejecuta fuera de las VMs de TPU, el proceso del controlador puede seguir ejecutándose mientras el administrador de recursos de Pathways recupera o reemplaza las porciones de TPU interrumpidas. Cuando necesites ejecutar código de Python local del host en las VMs de TPU, como la carga de datos de alta capacidad de procesamiento, el procesamiento previo o la creación de puntos de control, puedes usar Python ubicado en el mismo lugar para ejecutar funciones de Python específicas en las CPUs del host de TPU a través de un servidor sidecar.

Componentes de Pathways

La arquitectura de Pathways distribuye los componentes en tres entornos: el entorno de CPU del cliente, un nodo principal de CPU y las VMs de trabajador TPU. En el siguiente diagrama, se ilustra cómo interactúan estos componentes y dónde se ejecuta cada uno:

Diagrama de arquitectura que muestra cómo el programa JAX del usuario y el cliente proxy de IFRT incorporado se comunican con el servidor proxy de IFRT, el cliente de Pathways incorporado y el administrador de recursos de Pathways en el nodo principal de la CPU, y cómo esos componentes envían trabajo al trabajador de Pathways, al servidor de sidecar opcional y a los chips de Cloud TPU conectados en cada VM de trabajador de Cloud TPU.
Componentes de Pathways y ubicación del host

Entorno de CPU del cliente

Se ejecuta en un contenedor de carga de trabajo en el nodo principal de la CPU (típico para trabajos por lotes en GKE) o en un contenedor de cliente independiente, un trabajo de Slurm o una VM de CPU externa (para cargas de trabajo interactivas o Cluster Director):

  • Programa del usuario (controlador): Es tu proceso de JAX de Python, que define tu modelo, el bucle de entrenamiento y la fragmentación de dispositivos, y ve todos los chips TPU en las porciones como dispositivos locales.
  • Cliente proxy de IFRT: Es una biblioteca de Interim Framework Runtime (IFRT) de código abierto incorporada en tu proceso de JAX. Cuando importas pathwaysutils y configuras JAX_PLATFORMS=proxy, se desvincula tu código del entorno de ejecución subyacente y se envían solicitudes a través de gRPC al servidor proxy de IFRT.

Nodo principal de CPU

Se ejecuta en una VM dedicada solo para CPU en tu clúster (un nodo de grupo de nodos de CPU en GKE o un nodo de procesamiento de CPU en Cluster Director):

  • Servidor proxy de IFRT: Es un contenedor de servidor de gRPC que recibe solicitudes del cliente proxy de IFRT y las reenvía a su biblioteca cliente de Pathways incorporada.
  • Cliente de Pathways: Es una biblioteca del entorno de ejecución de IFRT incorporada en el contenedor del servidor proxy de IFRT. Envía programas del optimizador de alto nivel (HLO) al servicio de compilación en el administrador de recursos de Pathways y coordina la ubicación a través de gRPC. Luego, envía solicitudes de ejecución y datos de tensores a los trabajadores de Pathways, y presenta una vista unificada de los dispositivos a JAX.
  • Administrador de recursos de Pathways: Es el contenedor central del plano de control. Administra las porciones de aceleradores, supervisa el estado de los trabajadores, programa trabajos y aloja el servicio de compilación de Pathways, que compila programas de HLO en ejecutables de XLA almacenados en la caché de compilación en --gcs_scratch_location.

VMs de trabajador de Cloud TPU

Cada VM de trabajador TPU administra sus chips de Cloud TPU conectados (que ejecutan cálculos de XLA compilados) a través de contenedores de CPU de host:

  • Trabajador de Pathways: Carga ejecutables compilados desde la caché de compilación y recibe solicitudes de ejecución y datos de tensores del cliente de Pathways a través de gRPC. Ejecuta cálculos en los chips de Cloud TPU conectados, intercambia datos con otros trabajadores a través de interconexiones de alta velocidad y, además, informa el estado al administrador de recursos.
  • Servidor de archivo adicional (opcional, solo para GKE): Es un contenedor de gRPC (colocated-python-sidecar) que ejecuta funciones de Python especificadas por el usuario (como la carga de datos y la creación de puntos de control) en la VM de TPU. Intercambia búferes de tensores con el trabajador local de Pathways a través de la memoria de host compartida sin copia. Consulta Ejecuta Python coubicado con Pathways.

Componentes de Pathways en GKE

En GKE, el Pod pathways-head se ejecuta en un grupo de nodos de CPU y aloja pathways-rm y pathways-proxy (además del contenedor de carga de trabajo por lotes, cuando corresponda). Cada Pod de trabajador TPU ejecuta worker (o pathways-worker) y, cuando se habilita Python ubicado en el mismo lugar, colocated-python-sidecar.

Puedes encontrar imágenes de contenedor de Pathways en las siguientes ubicaciones:

Tipo de contenedor Ubicación

Servidor proxy de IFRT

us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/proxy_server:jax-JAX_VERSION

Administrador de recursos y trabajador de Pathways

us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/server:jax-JAX_VERSION

Sidecar de Python ubicado en el mismo lugar (opcional)

us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/colocated_python_sidecar:jax-JAX_VERSION

Administrador de recursos de Pathways

Después de crear un clúster de GKE, puedes usar el siguiente containerSpec para implementar el administrador de recursos de Pathways:

  - name: pathways-rm
    image: us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/server:latest
    imagePullPolicy: Always
    env:
    - name: HOST_ADDRESS
      valueFrom:
        fieldRef:
          fieldPath: "metadata.labels['jobset.sigs.k8s.io/coordinator']"
    - name: TPU_SKIP_MDS_QUERY
      value: "true"
    args:
    - --server_port=29001
    - --node_type=resource_manager
    - --instance_count=WORKLOAD_NODEPOOL_COUNT
    - --instance_type=SLICE_TOPOLOGY
    - --gcs_scratch_location=gs://BUCKET_NAME

Reemplaza lo siguiente:

  • WORKLOAD_NODEPOOL_COUNT: Es la cantidad de porciones de TPU.
  • SLICE_TOPOLOGY: Es el tipo de TPU y la topología de la porción, en el formato tpuTPU_TYPE:TOPOLOGY, por ejemplo, tpuv5e:4x4.
  • BUCKET_NAME: Es el bucket de Cloud Storage que se usa para los archivos temporales.

El contenedor también usa los siguientes argumentos:

  • --server_port: Es el puerto que usa el administrador de recursos de Pathways para comunicarse con otros componentes de Pathways (29001 en este ejemplo).
  • --node_type: Es el tipo de nodo. Establece este argumento en resource_manager para el administrador de recursos de Pathways. No es necesario para los demás contenedores.

Servidor proxy de IFRT

Puedes usar el siguiente containerSpec para implementar un servidor proxy de IFRT:

  - name: pathways-proxy
    image: us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/proxy_server:latest
    imagePullPolicy: Always
    env:
    - name: PATHWAYS_HEAD
      valueFrom:
        fieldRef:
          fieldPath: "metadata.labels['jobset.sigs.k8s.io/coordinator']"
    args:
    - --resource_manager_address=$(PATHWAYS_HEAD):29001
    - --server_port=29000
    - --gcs_scratch_location=gs://BUCKET_NAME
    ports:
    - containerPort: 29000

Reemplaza BUCKET_NAME por el nombre del bucket de Cloud Storage que se usa para los archivos temporales.

El contenedor también usa los siguientes argumentos:

  • --resource_manager_address: Es el nombre de host y el puerto que usa el servidor proxy para comunicarse con el administrador de recursos de Pathways. El puerto debe coincidir con el valor de --server_port que se usa para el contenedor del administrador de recursos de Pathways.
  • --server_port: Es el puerto que usa el servidor proxy de IFRT para comunicarse con el cliente proxy de IFRT (29000 en este ejemplo).
  • --gcs_scratch_location: Es la ruta de acceso de Cloud Storage que se usa para los archivos temporales.

Trabajador de Pathways

Puedes usar el siguiente containerSpec para implementar trabajadores de Pathways:

- name: worker
  image: us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/server:latest
  imagePullPolicy: Always
  env:
  - name: PATHWAYS_HEAD
    valueFrom:
      fieldRef:
        fieldPath: "metadata.labels['jobset.sigs.k8s.io/coordinator']"
  - name: MEGASCALE_NUM_SLICES
    valueFrom:
      fieldRef:
        fieldPath: "metadata.labels['jobset.sigs.k8s.io/replicatedjob-replicas']"
  - name: MEGASCALE_SLICE_ID
    valueFrom:
      fieldRef:
        fieldPath: "metadata.labels['jobset.sigs.k8s.io/job-index']"
  - name: MEGASCALE_COORDINATOR_ADDRESS
    value: "$(PATHWAYS_HEAD)"
  args:
  - --server_port=29001
  - --resource_manager_address=$(PATHWAYS_HEAD):29001
  - --gcs_scratch_location=gs://BUCKET_NAME
  ports:
  - containerPort: 29001
  resources:
    limits:
      google.com/tpu: "4"

Reemplaza BUCKET_NAME por el nombre del bucket de Cloud Storage que se usa para los archivos temporales.

El contenedor también usa los siguientes argumentos:

  • --server_port: Es el puerto que usan los trabajadores para comunicarse con el servidor proxy y el administrador de recursos de Pathways (29001 en este ejemplo).
  • --resource_manager_address: Es el nombre de host y el puerto que usan los trabajadores de TPU para comunicarse con el administrador de recursos de Pathways. El puerto debe coincidir con el valor de --server_port que se usa para el contenedor del administrador de recursos de Pathways.
  • --gcs_scratch_location: Es la ruta de acceso de Cloud Storage que se usa para los archivos temporales.

El administrador de recursos de Pathways, el servidor proxy de IFRT y los trabajadores de Pathways pueden tener puertos diferentes, pero, en este ejemplo, el administrador de recursos de Pathways y el trabajador de Pathways comparten el mismo puerto.

Componentes de Pathways en Cluster Director

En esta sección, se asignan los componentes de Pathways a los trabajos de Slurm en un clúster de Cluster Director.

Las secuencias de comandos de Pathways ejecutan los componentes de Pathways con Enroot. La secuencia de comandos setup_env.sh usa las siguientes imágenes de contenedor, que coinciden con la versión de JAX (0.11.1) del entorno de Python que compila:

Tipo de contenedor Ubicación

Servidor proxy de IFRT

us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/proxy_server:jax-0.11.1

Administrador de recursos y trabajador de Pathways

us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/server:jax-0.11.1

Para iniciar los componentes de Pathways, envía la secuencia de comandos start_pathways.sh como el trabajo de servicio de Pathways. No escribas los siguientes comandos por tu cuenta. Las secuencias de comandos derivan los argumentos de las variables de entorno que configuras cuando envías start_pathways.sh, como SLICE_SHAPE, MIN_SLICES, MAX_SLICES y GCS_BUCKET.

Administrador de recursos de Pathways

El trabajo del servicio de Pathways ejecuta el administrador de recursos de Pathways en un nodo de CPU. Ejecuta el siguiente comando en el contenedor del servidor de Pathways:

/pathways/server \
    --server_port=29001 \
    --node_type=resource_manager \
    --instance_type=tpuTPU_TYPE:TOPOLOGY \
    --instance_count=MAX_SLICES \
    --gcs_scratch_location=gs://BUCKET_NAME/pathways-scratch/shared \
    --enable_gcs_olm=false

La secuencia de comandos propaga los siguientes marcadores de posición en el comando:

  • TPU_TYPE y TOPOLOGY: el tipo de TPU y la topología de cada porción, derivados de SLICE_SHAPE; por ejemplo, SLICE_SHAPE=2x4 establece tpuv6e:2x4.
  • MAX_SLICES: Es la cantidad máxima de porciones de TPU, de MAX_SLICES.
  • BUCKET_NAME: el nombre de tu bucket de Cloud Storage, de GCS_BUCKET.

El comando usa los siguientes argumentos:

  • --server_port: Es el puerto en el que escucha el administrador de recursos de Pathways. El servidor proxy de IFRT y los trabajadores de Pathways se conectan a este puerto.
  • --node_type: el tipo de nodo, resource_manager. Solo el administrador de recursos de Pathways establece este argumento.
  • --instance_type: Es el tipo de TPU y la topología de cada porción.
  • --instance_count: Es la cantidad de porciones de TPU.
  • --gcs_scratch_location: Es la ruta de acceso de Cloud Storage que se usa para los archivos temporales, como la caché de compilación.
  • --enable_gcs_olm: indica si Pathways crea reglas de ciclo de vida de objetos de Cloud Storage para limpiar las entradas de caché de compilación antiguas. La secuencia de comandos desactiva esta opción porque requiere permisos adicionales en el bucket.

Servidor proxy de IFRT

El trabajo del servicio de Pathways ejecuta el servidor proxy de IFRT en el mismo nodo de CPU que el administrador de recursos de Pathways. Ejecuta el siguiente comando en el contenedor del servidor proxy de IFRT:

/pathways/proxy_server \
    --server_port=29000 \
    --resource_manager_address=RM_IP:29001 \
    --gcs_scratch_location=gs://BUCKET_NAME/pathways-scratch/shared \
    --num_elastic_instances=MAX_SLICES

La secuencia de comandos propaga los siguientes marcadores de posición en el comando:

  • RM_IP: Es la dirección IP interna del nodo de CPU que ejecuta el administrador de recursos de Pathways.
  • BUCKET_NAME: el nombre de tu bucket de Cloud Storage, de GCS_BUCKET.
  • MAX_SLICES: Es la cantidad máxima de porciones de TPU, de MAX_SLICES.

El comando usa los siguientes argumentos:

  • --server_port: Es el puerto en el que escucha el servidor proxy de IFRT. Tu programa de JAX se conecta a este puerto.
  • --resource_manager_address: Es la dirección y el puerto del administrador de recursos de Pathways.
  • --gcs_scratch_location: Es la misma ruta de acceso de Cloud Storage que el administrador de recursos de Pathways.
  • --num_elastic_instances: Es la cantidad de porciones que pueden no estar disponibles sin detener la sesión del proxy de IFRT, de MAX_SLICES. Tu carga de trabajo aplica de manera forzosa MIN_SLICES.

Cuando se ejecutan al menos MIN_SLICES porciones, el trabajo de servicio escribe la dirección del servidor proxy de IFRT en ~/pathways/cluster.env. Tu programa de JAX, el cliente proxy de IFRT, lee este archivo para conectarse a Pathways. El programa de JAX se ejecuta como tu carga de trabajo, por ejemplo, run_maxtext.sh, o en un notebook de Jupyter.

Trabajador de Pathways

El trabajo de servicio de Pathways envía un array de trabajos de Slurm (run_worker_slice.sh) con una tarea de array para cada porción de TPU. Cada tarea de array ejecuta el siguiente comando en el contenedor del servidor de Pathways en cada VM de TPU de su porción:

/pathways/server \
    --server_port=29001 \
    --resource_manager_address=RM_IP:29001 \
    --gcs_scratch_location=gs://BUCKET_NAME/pathways-scratch/shared \
    --enable_gcs_olm=false

La secuencia de comandos propaga RM_IP con la dirección IP interna del nodo de CPU y BUCKET_NAME con el nombre de tu bucket de Cloud Storage.

El comando usa los siguientes argumentos:

  • --server_port: Es el puerto en el que escucha el trabajador de Pathways. El administrador de recursos de Pathways y el servidor proxy de IFRT se conectan a este puerto.
  • --resource_manager_address: Es la dirección del administrador de recursos de Pathways, la misma que para el servidor proxy de IFRT.
  • --gcs_scratch_location y --enable_gcs_olm: Es lo mismo que para el administrador de recursos de Pathways.

La secuencia de comandos también establece la topología de TPU y las variables de entorno MEGASCALE_* para cada trabajador a partir de los nodos de la porción y el índice de tareas del array.

Si se interrumpe o falla una porción de TPU, Slurm vuelve a poner en cola su tarea de array. Si tienes SSH sin contraseñasudo en los nodos del clúster, el trabajo de servicio también apaga los nodos de la porción para que Slurm pueda volver a crearlos. El administrador de recursos de Pathways y el servidor proxy de IFRT siguen ejecutándose, por lo que tu programa de JAX no necesita conectarse a una dirección nueva.

¿Qué sigue?