Introduzione ai percorsi su Cloud

Pathways è un runtime distribuito per JAX che utilizza un modello di esecuzione con un singolo controller per orchestrare workload di machine learning (ML) su larga scala, multi-task e attivati in modo sparso su una o più sezioni TPU. Consente a un singolo processo Python (il controller) di coordinare i calcoli su migliaia o decine di migliaia di chip TPU e di allocare dinamicamente il calcolo tra le attività.

Anziché eseguire una copia separata del programma Python su ogni VM TPU, il workload JAX viene eseguito in un processo CPU client (il controller) e comunica tramite gRPC con un control plane Pathways su un nodo head della CPU, ovvero una VM dedicata solo alla CPU nel cluster che ospita i servizi di coordinamento e compilazione di Pathways. Il control plane compila il codice e invia i calcoli ai worker Pathways in esecuzione sulle VM TPU.

Google utilizza Pathways internamente per addestrare modelli di grandi dimensioni come Gemini. Pathways on Cloud offre la stessa architettura ai clienti Google Cloud .

Prima di iniziare

Puoi eseguire Pathways su Google Kubernetes Engine (GKE) o su un cluster Cluster Director con Slurm. Seleziona la scheda della tua piattaforma per visualizzare i prerequisiti.

GKE

Completa i seguenti prerequisiti:

Questo documento presuppone che tu abbia già familiarità con l'utilizzo delle TPU in GKE, incluse le TPU a sezione singola e multisezione su GKE, e che tu abbia un'esperienza generale con le TPU multisezione.

Per creare un cluster, consulta Crea un cluster GKE con Pathways.

Cluster Director

Completa i seguenti prerequisiti:

Questo documento presuppone che tu abbia già familiarità con Cluster Director, macchine TPU in Cluster Director e l'esecuzione di job con Slurm e che tu abbia un'esperienza generale con TPU multislice.

Per creare un cluster, consulta Crea un cluster Cluster Director con Pathways.

Controller singolo e multicontroller

I workload ML distribuiti su TPU utilizzano un modello di esecuzione multi-controller (l'impostazione predefinita in JAX) o un modello di esecuzione single-controller (utilizzato da Pathways). I due modelli differiscono per il punto in cui viene eseguito il codice Python, per il modo in cui il programma visualizza gli acceleratori e per il modo in cui i workload vengono coordinati tra le sezioni TPU.

Workload multi-controller (impostazione predefinita di JAX)

Nel modello multi-controller, ogni VM TPU nelle sezioni TPU esegue lo stesso script Python. Ogni VM TPU funge da controller indipendente per i chip TPU collegati direttamente all'host. I workload multi-controller hanno le seguenti caratteristiche:

  • Controllo distribuito: ogni VM TPU esegue una copia dello script Python in sincronia e coordina le operazioni collettive tra i processi.
  • Visualizzazione dei dispositivi localizzati: ogni processo Python gestisce direttamente solo i chip TPU collegati alla sua VM locale (jax.local_devices()), mentre jax.devices() elenca tutti i dispositivi nel cluster.
  • Esecuzione SPMD (Single Program, Multiple Data): poiché ogni host esegue lo stesso script contemporaneamente, i workload multi-controller seguono principalmente il paradigma SPMD. L'orchestrazione di operazioni diverse su sottoinsiemi diversi di sezioni TPU richiede una logica di coordinamento multi-host personalizzata.
  • Ciclo di vita accoppiato all'host: poiché i controller Python vengono eseguiti direttamente sulle VM TPU, se una VM TPU viene prerilasciata o non funziona, tutti i processi del controller devono arrestarsi e riavviarsi insieme.

Workload con controller singolo (Pathways)

Nel modello a controller singolo di Pathways, un singolo processo Python funge da controller centrale per l'intero workload. Il programma JAX (il controller) viene eseguito su un host CPU, ad esempio un container batch su un nodo head della CPU o una VM client esterna, e comunica con il runtime Pathways tramite gRPC anziché essere eseguito direttamente sulle VM TPU. I workload con un singolo controller hanno le seguenti caratteristiche:

  • Controllo centralizzato: esegui e monitori un processo del controller Python che invia i calcoli al runtime di Pathways, che gestisce l'esecuzione in tutte le VM TPU.
  • Visualizzazione unificata dei dispositivi: il programma JAX vede tutte le sezioni TPU come un unico sistema unificato. Nel codice, jax.process_index() è sempre 0 e sia jax.devices() che jax.local_devices() restituiscono ogni chip TPU in tutti gli slice allocati come se fossero collegati a una singola macchina di grandi dimensioni.
  • Pattern di calcolo flessibili: oltre all'addestramento SPMD standard, un singolo controller può pianificare calcoli diversi su sottoinsiemi distinti di acceleratori, supportando il parallelismo della pipeline asimmetrico, i workload multitasking e la scarsità computazionale.
  • Ciclo di vita del controller disaccoppiato: poiché il programma Python viene eseguito all'esterno delle VM TPU, il processo del controller può rimanere in esecuzione mentre il gestore delle risorse Pathways recupera o sostituisce le sezioni TPU prerilasciate. Quando devi eseguire il codice Python locale dell'host sulle VM TPU, ad esempio per il caricamento, la pre-elaborazione o il checkpoint dei dati con throughput elevato, puoi utilizzare Python in co-locazione per eseguire funzioni Python specifiche sulle CPU host TPU tramite un server sidecar.

Componenti di Pathways

L'architettura Pathways distribuisce i componenti in tre ambienti: l'ambiente CPU client, un nodo head della CPU e le VM worker TPU. Il seguente diagramma illustra l'interazione tra questi componenti e dove viene eseguito ciascuno:

Diagramma dell'architettura che mostra come il programma JAX dell'utente e il client proxy IFRT incorporato comunicano con il server proxy IFRT, il client Pathways incorporato e il gestore delle risorse Pathways sul nodo principale della CPU e come questi componenti inviano il lavoro al worker Pathways, al server sidecar facoltativo e ai chip Cloud TPU collegati su ogni worker TPU VM.
Componenti di Pathways e posizionamento dell'host

Ambiente CPU client

Viene eseguito in un container del workload sul nodo head della CPU (tipico per i job batch su GKE) o in un container client separato, un job Slurm o una VM CPU esterna (per workload interattivi o Cluster Director):

  • Programma utente (controller): il processo JAX Python, che definisce il modello, il ciclo di addestramento e lo sharding dei dispositivi e vede tutti i chip TPU tra le sezioni come dispositivi locali.
  • Client proxy IFRT: una libreria open source Interim Framework Runtime (IFRT) incorporata nel processo JAX. Quando importi pathwaysutils e imposti JAX_PLATFORMS=proxy, il codice viene disaccoppiato dal runtime sottostante e le richieste vengono inviate tramite gRPC al server proxy IFRT.

Nodo head della CPU

Viene eseguito su una VM dedicata solo per CPU nel cluster (un nodo del pool di nodi della CPU su GKE o un nodo di computing della CPU su Cluster Director):

  • Server proxy IFRT: un contenitore del server gRPC che riceve le richieste dal client proxy IFRT e le inoltra alla libreria client Pathways incorporata.
  • Client Pathways: una libreria di runtime IFRT incorporata nel contenitore del server proxy IFRT. Invia programmi HLO (High-Level Optimizer) al servizio di compilazione nel gestore delle risorse Pathways e coordina il posizionamento tramite gRPC. Quindi invia le richieste di esecuzione e i dati dei tensori ai worker Pathways e presenta una visualizzazione unificata dei dispositivi a JAX.
  • Pathways resource manager: il container del control plane centrale. Gestisce le sezioni dell'acceleratore, monitora lo stato dei worker, pianifica i job e ospita il servizio di compilazione Pathways, che compila i programmi HLO in eseguibili XLA archiviati nella cache di compilazione in --gcs_scratch_location.

VM worker Cloud TPU

Ogni VM worker TPU gestisce i chip Cloud TPU collegati (che eseguono calcoli XLA compilati) tramite i container della CPU host:

  • Worker Pathways: carica i file eseguibili compilati dalla cache di compilazione e riceve richieste di esecuzione e dati dei tensori dal client Pathways tramite gRPC. Esegue calcoli sui chip Cloud TPU collegati, scambia dati con altri worker tramite interconnessioni ad alta velocità e segnala lo stato di integrità a Resource Manager.
  • Server sidecar (facoltativo, solo GKE): un container gRPC (colocated-python-sidecar) che esegue funzioni Python specificate dall'utente (come il caricamento dei dati e il checkpoint) sulla VM TPU. Scambia i buffer dei tensori con il worker Pathways locale tramite la memoria host condivisa con copia zero. Consulta Esegui Python in co-locazione con Pathways.

Componenti Pathways su GKE

In GKE, il pod pathways-head viene eseguito su un pool di nodi di CPU e ospita pathways-rm e pathways-proxy (oltre al container del workload batch, se applicabile). Ogni pod worker TPU esegue worker (o pathways-worker) e, se Python in co-locazione è abilitato, colocated-python-sidecar.

Puoi trovare le immagini container di Pathways nelle seguenti posizioni:

Tipo di contenitore Località

Server proxy IFRT

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

Pathways resource manager and worker

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

Sidecar Python in co-location (facoltativo)

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

Pathways resource manager

Dopo aver creato un cluster GKE, puoi utilizzare il seguente containerSpec per eseguire il deployment del resource manager di 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

Sostituisci quanto segue:

  • WORKLOAD_NODEPOOL_COUNT: il numero di sezioni TPU.
  • SLICE_TOPOLOGY: il tipo di TPU e la topologia della sezione, nel formato tpuTPU_TYPE:TOPOLOGY, ad esempio tpuv5e:4x4.
  • BUCKET_NAME: il bucket Cloud Storage utilizzato per i file temporanei.

Il container utilizza anche i seguenti argomenti:

  • --server_port: la porta utilizzata dal gestore delle risorse Pathways per comunicare con altri componenti Pathways (29001 in questo esempio).
  • --node_type: il tipo di nodo. Imposta questo argomento su resource_manager per il gestore delle risorse Pathways. Non è necessario per gli altri container.

Server proxy IFRT

Puoi utilizzare il seguente containerSpec per eseguire il deployment di un server proxy 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

Sostituisci BUCKET_NAME con il nome del bucket Cloud Storage utilizzato per i file temporanei.

Il container utilizza anche i seguenti argomenti:

  • --resource_manager_address: il nome host e la porta utilizzati dal server proxy per comunicare con Pathways Resource Manager. La porta deve corrispondere al valore --server_port utilizzato per il container del gestore delle risorse Pathways.
  • --server_port: la porta utilizzata dal server proxy IFRT per comunicare con il client proxy IFRT (29000 in questo esempio).
  • --gcs_scratch_location: il percorso Cloud Storage utilizzato per i file temporanei.

Lavoratore Pathways

Puoi utilizzare i seguenti containerSpec per eseguire il deployment dei worker 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"

Sostituisci BUCKET_NAME con il nome del bucket Cloud Storage utilizzato per i file temporanei.

Il container utilizza anche i seguenti argomenti:

  • --server_port: la porta utilizzata dai worker per comunicare con il server proxy e il gestore delle risorse Pathways (29001 in questo esempio).
  • --resource_manager_address: il nome host e la porta utilizzati dai worker TPU per comunicare con il gestore delle risorse Pathways. La porta deve corrispondere al valore --server_port utilizzato per il container del gestore delle risorse Pathways.
  • --gcs_scratch_location: il percorso Cloud Storage utilizzato per i file temporanei.

Il gestore delle risorse Pathways, il server proxy IFRT e i worker Pathways possono avere tutti porte diverse, ma in questo esempio il gestore delle risorse Pathways e il worker Pathways condividono la stessa porta.

Componenti Pathways su Cluster Director

Questa sezione mappa i componenti di Pathways ai job Slurm su un cluster Cluster Director.

Gli script Pathways eseguono i componenti Pathways con Enroot. Lo script setup_env.sh utilizza le seguenti immagini container, che corrispondono alla versione JAX (0.11.1) dell'ambiente Python che crea:

Tipo di contenitore Località

Server proxy IFRT

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

Pathways resource manager and worker

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

Per avviare i componenti Pathways, invia lo script start_pathways.sh come job del servizio Pathways. Non devi scrivere personalmente i seguenti comandi. Gli script derivano gli argomenti dalle variabili di ambiente impostate quando invii start_pathways.sh, ad esempio SLICE_SHAPE, MIN_SLICES, MAX_SLICES e GCS_BUCKET.

Pathways resource manager

Il job del servizio Pathways esegue il gestore delle risorse Pathways su un nodo CPU. Esegue il seguente comando nel contenitore del server 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

Lo script compila i seguenti segnaposto nel comando:

  • TPU_TYPE e TOPOLOGY: il tipo di TPU e la topologia di ogni sezione, derivati da SLICE_SHAPE, ad esempio SLICE_SHAPE=2x4 imposta tpuv6e:2x4.
  • MAX_SLICES: il numero massimo di sezioni TPU, da MAX_SLICES.
  • BUCKET_NAME: il nome del tuo bucket Cloud Storage, da GCS_BUCKET.

Il comando utilizza i seguenti argomenti:

  • --server_port: la porta su cui ascolta il gestore delle risorse Pathways. Il server proxy IFRT e i worker Pathways si connettono a questa porta.
  • --node_type: il tipo di nodo, resource_manager. Solo il gestore delle risorse Pathways imposta questo argomento.
  • --instance_type: il tipo di TPU e la topologia di ogni sezione.
  • --instance_count: il numero di sezioni TPU.
  • --gcs_scratch_location: il percorso Cloud Storage utilizzato per i file temporanei, ad esempio la cache di compilazione.
  • --enable_gcs_olm: indica se Pathways crea regole del ciclo di vita degli oggetti Cloud Storage per ripulire le voci della cache di compilazione precedenti. Lo script disattiva questa opzione perché richiede autorizzazioni aggiuntive sul bucket.

Server proxy IFRT

Il job del servizio Pathways esegue il server proxy IFRT sullo stesso nodo CPU del gestore delle risorse Pathways. Esegue il seguente comando nel contenitore del server proxy 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

Lo script compila i seguenti segnaposto nel comando:

  • RM_IP: l'indirizzo IP interno del nodo CPU che esegue il gestore delle risorse Pathways.
  • BUCKET_NAME: il nome del tuo bucket Cloud Storage, da GCS_BUCKET.
  • MAX_SLICES: il numero massimo di sezioni TPU, da MAX_SLICES.

Il comando utilizza i seguenti argomenti:

  • --server_port: la porta su cui il server proxy IFRT rimane in ascolto. Il tuo programma JAX si connette a questa porta.
  • --resource_manager_address: l'indirizzo e la porta del gestore delle risorse Pathways.
  • --gcs_scratch_location: lo stesso percorso Cloud Storage del gestore delle risorse Pathways.
  • --num_elastic_instances: il numero di sezioni che possono non essere disponibili senza interrompere la sessione del proxy IFRT, da MAX_SLICES. Il tuo workload applica MIN_SLICES.

Quando sono in esecuzione almeno MIN_SLICES sezioni, il job del servizio scrive l'indirizzo del server proxy IFRT in ~/pathways/cluster.env. Il tuo programma JAX, il client proxy IFRT, legge questo file per connettersi a Pathways. Il programma JAX viene eseguito come workload, ad esempio run_maxtext.sh, o in un notebook Jupyter.

Lavoratore Pathways

Il job del servizio Pathways invia un array di job Slurm (run_worker_slice.sh) con un'attività dell'array per ogni sezione TPU. Ogni attività dell'array esegue il seguente comando nel contenitore del server Pathways su ogni VM TPU nella sua sezione:

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

Lo script compila RM_IP con l'indirizzo IP interno del nodo CPU e BUCKET_NAME con il nome del bucket Cloud Storage.

Il comando utilizza i seguenti argomenti:

  • --server_port: la porta su cui è in ascolto il worker Pathways. Il gestore delle risorse Pathways e il server proxy IFRT si connettono a questa porta.
  • --resource_manager_address: l'indirizzo del gestore delle risorse Pathways, lo stesso del server proxy IFRT.
  • --gcs_scratch_location e --enable_gcs_olm: gli stessi del gestore delle risorse Pathways.

Lo script imposta anche la topologia TPU e le variabili di ambiente MEGASCALE_* per ogni worker dai nodi della sezione e dall'indice delle attività dell'array.

Se una sezione TPU viene prerilasciata o non funziona, Slurm mette nuovamente in coda il relativo job di array. Se hai passwordless sudo sui nodi del cluster, il job di servizio spegne anche i nodi dello slice in modo che Slurm possa ricrearli. Il gestore delle risorse Pathways e il server proxy IFRT continuano a funzionare, quindi il tuo programma JAX non deve connettersi a un nuovo indirizzo.

Passaggi successivi