Formazione resiliente con Pathways

Questa pagina spiega come gli ingegneri di machine learning possono configurare le funzionalità di resilienza per i workload Pathways su Google Kubernetes Engine (GKE) in modo che i job di addestramento su larga scala possano riprendersi da interruzioni pianificate e guasti hardware non pianificati.

Pathways offre vantaggi in termini di resilienza nei seguenti modi:

  • Sospensione-ripristino: consente al workload di tollerare interruzioni pianificate, come le notifiche di prerilascio, senza richiedere un codice di gestione del prerilascio personalizzato.
  • Addestramento elastico: consente al workload di tollerare errori hardware non pianificati senza arrestare in modo anomalo il client utilizzando la logica di recupero nel codice di addestramento.
  • Checkpointing multilivello: consente al workload di salvare checkpoint locali ad alta frequenza e replicati tra i peer nei worker Cloud TPU utilizzando Python in co-locazione, con backup asincroni di Cloud Storage per ridurre i tempi di ripristino.
  • Hot-swap: consente a un workload GKE JobSet con priorità più alta di assumere rapidamente il controllo delle sezioni Cloud TPU di riserva o con priorità più bassa quando si verifica un guasto hardware.

Prima di iniziare

Completa i seguenti prerequisiti:

Se utilizzi l'addestramento elastico, installa i seguenti pacchetti nell'immagine container del workload:

  • pathwaysutils
  • Orbax (orbax-checkpoint): >= 0.12.6 (obbligatorio per gli snapshot in memoria con ocp.v1.training.pathways.Snapshotter)
  • Grain (grain): obbligatorio se utilizzi grain.experimental.ElasticIterator

Se utilizzi il checkpointing multilivello, completa anche i seguenti prerequisiti:

  • Configura il cluster GKE per il checkpoint multilivello seguendo le istruzioni riportate in Addestra modelli di machine learning su larga scala su GKE con il checkpoint multilivello:
    • Abilita i componenti aggiuntivi Multi-Tier Checkpointing (HighScaleCheckpointing) e Cloud Storage FUSE (GcsFuseCsiDriver), insieme a Workload Identity Federation for GKE, sul tuo cluster.
    • Crea un bucket Cloud Storage con lo spazio dei nomi gerarchico abilitato.
    • Concedi il ruolo Identity and Access Management (IAM) Storage Object User (roles/storage.objectUser) sul bucket al account di servizio Kubernetes GKE Multi-Tier Checkpointing (gke-checkpointing-multitier-node in gke-managed-checkpointing).
    • Esegui il deployment di una risorsa personalizzata CheckpointConfiguration specificando il tuo bucket Cloud Storage, il selettore di nodi Cloud TPU e le dimensioni del volume in memoria (inMemoryVolumeSize).
  • Crea ed esegui il push di un'immagine container sidecar Python 3.12 collocata seguendo le istruzioni riportate in Esegui Python collocato con Pathways, ad esempio in base a sample_sidecar.dockerfile in pathways-utils. Se il file requirements.txt o Dockerfile installa pacchetti da URL Git, installa prima git con apt-get perché l'immagine di base slim omette git. Utilizza Python 3.12 e le versioni jax e jaxlib corrispondenti nelle immagini del workload e del sidecar, rispettando queste versioni minime:
    • Orbax (orbax-checkpoint): >= 0.12.4
    • JAX (jax e jaxlib): >= 0.10.1

Sospensione-ripristino

In genere, GKE invia una notifica di prerilascio a un pod acceleratore prima di prerilasciarlo. Pathways attiva la tolleranza di prelazione per impostazione predefinita su tutti i deployment cloud e i job dell'acceleratore Pathways ascoltano queste notifiche.

Quando arriva una notifica di prerilascio, Pathways determina innanzitutto se può salvare e ripristinare il workload. Se possibile, Pathways tenta di sospendere il workload ML scrivendo lo stato attuale nello spazio di archiviazione permanente, ad esempio Cloud Storage, prima che GKE rimuova i job dell'acceleratore. Quando GKE ripianifica i job in un secondo momento, Pathways riprende il workload ML leggendo lo stato persistente.

Se il workload non è ripristinabile, Pathways arresta il job dell'acceleratore interessato e genera un jax.errors.JaxRuntimeError nel processo client del controller singolo se è configurato l'addestramento elastico. Se l'addestramento elastico non è configurato, GKE riavvia l'intero workload in base alla policy di riavvio JobSet.

I workload ML tipici definiti con JAX si basano su componenti XLA Pathways stateless, che possono essere ripristinati utilizzando uno snapshot della memoria a larghezza di banda elevata (HBM). Alcuni workload ML, come quelli definiti con l'API Python collocata di JAX, si basano su componenti Pathways stateful e non sono ripristinabili.

Addestramento elastico

L'addestramento elastico consente al job di addestramento di continuare quando si verificano guasti hardware o prerilasci di sezioni, senza riavviare l'intero workload. In un job di addestramento multislice, Pathways mantiene attivi il processo client del controller singolo e le sezioni Cloud TPU integre quando una singola sezione non è disponibile.

L'addestramento elastico combina le funzionalità del sistema Pathways con la logica di recupero nel codice di addestramento:

  • Rilevamento degli errori: quando si verifica un errore hardware o un prerilascio su una sezione Cloud TPU, Pathways annulla l'assegnazione della sezione interessata e genera un jax.errors.JaxRuntimeError la volta successiva che il workload accede ai dati su quella sezione. Poiché il processo client rimane attivo, il codice può rilevare questo errore, riconfigurare le risorse e continuare l'addestramento.
  • Modalità di recovery: la classe pathwaysutils.elastic.manager.Manager e il relativo decoratore elastic_retry supportano due strategie di recovery:
    • Metti in pausa e riprendi: se imposti minimum_slice_count su None o sul numero totale di sezioni, l'addestramento viene messo in pausa quando una sezione non va a buon fine e riprende quando tutte le sezioni sono di nuovo integre. Poiché il numero di sezioni non cambia tra i tentativi, il workload può riutilizzare il mesh di dispositivi esistente e gli eseguibili compilati.
    • Ridimensionamento delle repliche: se imposti minimum_slice_count su un valore inferiore al numero totale di sezioni, l'addestramento continua sulle sezioni attive rimanenti quando una sezione non riesce. Il workload ricrea la mesh dei dispositivi e ricompila per la topologia più piccola. Un thread di monitoraggio in background controlla periodicamente le sezioni inattive e registra le sezioni appena diventate integre in elastic_manager.available_inactive_slices. Il loop di addestramento può quindi ricostruire la mesh dei dispositivi con gli slice sostitutivi, reinizializzare per la topologia espansa e posizionare lo stato attuale sulla nuova mesh.
  • Recupero dello stato: per riprendere l'addestramento dopo un evento elastico, il workload ripristina i parametri del modello, lo stato dell'ottimizzatore e lo stato dell'iteratore dei dati utilizzando snapshot in memoria. ocp.v1.training.pathways.Snapshotter in orbax.checkpoint copia in modo asincrono lo stato replicato dalla memoria HBM di Cloud TPU alla memoria della CPU pinned_host su ogni sezione. Durante il recupero, Snapshotter ricostruisce lo stato dalle repliche host sopravvissute e lo ripartisce direttamente sulla mesh Cloud TPU attiva senza leggere dallo spazio di archiviazione remoto.

Abilita l'elasticità sul server proxy Pathways

Per abilitare i set di dispositivi elastici su Pathways in GKE, aggiungi il flag --num_elastic_instances al campo args del container pathways-proxy nel manifest JobSet e specifica il numero di sezioni Cloud TPU elastiche nel tuo workload:

- name: pathways-proxy
  image: us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways/proxy_server:jax-JAX_VERSION
  args:
  - --resource_manager_address=$(PATHWAYS_HEAD):29001
  - --server_port=29000
  - --gcs_scratch_location=gs://BUCKET_NAME
  - --num_elastic_instances=NUM_SLICES

Sostituisci quanto segue:

  • JAX_VERSION: il tag della versione JAX (ad esempio 0.12.0.1) che corrisponde alle immagini del server e del workload Pathways.
  • BUCKET_NAME: il bucket Cloud Storage utilizzato per i file temporanei di Pathways.
  • NUM_SLICES: il numero di slice Cloud TPU nel tuo workload.

Filtra i dispositivi attivi e crea la rete di dispositivi

In un workload Pathways, jax.devices() restituisce un elenco statico di tutti i dispositivi dall'avvio e non si aggiorna se uno slice non va a buon fine o viene recuperato. Quando utilizzi l'addestramento elastico, utilizza elastic_manager.active_devices in modo che la mesh del dispositivo e le dimensioni del batch utilizzino solo slice attive e integre:

import jax
import numpy as np
from pathwaysutils.elastic import manager

elastic_manager = manager.Manager()


def create_mesh(
    elastic_manager: manager.Manager, devices_per_slice: int
) -> jax.sharding.Mesh:
  device_array = np.asarray(elastic_manager.active_devices).reshape(
      (elastic_manager.active_slice_count, devices_per_slice)
  )
  return jax.sharding.Mesh(device_array, axis_names=("replica", "model"))

Quando il numero di sezioni attive cambia in modalità di ridimensionamento delle repliche, utilizza un caricatore di dati elastico come grain.experimental.ElasticIterator. Gli iteratori di dati standard per host salvano lo stato per host e non possono essere ripristinati su un numero diverso di host. Al contrario, ElasticIterator monitora una singola posizione del set di dati globale che puoi ripristinare in un numero qualsiasi di sezioni attive.

Loop di addestramento elastico

Un ciclo di addestramento elastico coordina il monitoraggio degli slice, il recupero dagli errori e la creazione di snapshot in memoria combinando manager.Manager, elastic_retry e Snapshotter in memoria di Orbax, come mostrato nell'esempio seguente:

import jax
import orbax.checkpoint as ocp
import pathwaysutils
from pathwaysutils.elastic import manager

pathwaysutils.initialize()


def train(
    final_step: int,
    snapshot_interval: int,  # in steps
    devices_per_slice: int,
):
  # Create a single Manager and Snapshotter outside the retry wrapper so slice
  # tracking and host-memory snapshots persist across attempts.
  elastic_manager = manager.Manager()
  snapshotter = ocp.v1.training.pathways.Snapshotter(replica_axis_index=0)

  # Decorate the full training loop to wait for healthy slices, monitor
  # inactive slices, and retry on jax.errors.JaxRuntimeError.
  @elastic_manager.elastic_retry(
      minimum_slice_count=1,
      poll_interval=10,  # in seconds
      timeout=300,  # in seconds
      retry_policy=manager.ElasticRetryLimit(max_attempts=10),
  )
  def run_training_loop():
    # Rebuild the mesh from elastic_manager.active_devices and let device
    # buffers from any failed attempt go out of scope so JAX frees memory.
    mesh = create_mesh(elastic_manager, devices_per_slice)
    state, abstract_state, jitted_train_step, data_iterator = (
        initialize_training_loop(mesh)
    )
    step = 0

    # Restore the latest in-memory snapshot onto the updated mesh shardings.
    if snapshotter.latest is not None:
      snapshotter.join()
      restored = snapshotter.load({
          "state": abstract_state,
          "step": step,
          "iterator_state": data_iterator.get_state(),
      })
      state = restored["state"]
      step = int(restored["step"]) + 1
      data_iterator.set_state(restored["iterator_state"])

    while step < final_step:
      batch = next(data_iterator)
      state = jitted_train_step(state, batch)

      # Periodically back up training state to host-memory snapshots.
      if step % snapshot_interval == 0:
        snapshotter.save(
            step,
            {
                "state": state,
                "step": step,
                "iterator_state": data_iterator.get_state(),
            },
        )

      # Detect healthy replacement slices, add them to active_slice_indices,
      # rebuild the mesh, reinitialize, and place state onto the expanded mesh.
      if elastic_manager.available_inactive_slices:
        elastic_manager.active_slice_indices |= (
            elastic_manager.available_inactive_slices
        )
        mesh = create_mesh(elastic_manager, devices_per_slice)
        iterator_state = data_iterator.get_state()
        _, abstract_state, jitted_train_step, data_iterator = (
            initialize_training_loop(mesh)
        )
        data_iterator.set_state(iterator_state)
        state_shardings = jax.tree.map(lambda x: x.sharding, abstract_state)
        state = jax.device_put(state, state_shardings)

      step += 1

    return state

  state = run_training_loop()
  snapshotter.join()
  return state

Configura l'elastic manager e il comportamento di ripetizione

Crea un'istanza di manager.Manager(devices=None) una volta per processo. Se ometti devices, il gestore utilizza jax.devices() e raggruppa i dispositivi in base al relativo attributo slice_index.

L'istanza Manager espone le seguenti proprietà per ispezionare la topologia del cluster durante l'addestramento:

  • slice_to_devices: una mappatura da ogni slice_index alla sequenza di oggetti jax.Device che appartengono a quella sezione.
  • all_slice_indices: un frozenset di tutti gli indici delle sezioni nell'allocazione.
  • active_slice_indices: un frozenset di indici di sezioni che partecipano al mesh di calcolo attivo.
  • active_devices: un elenco di oggetti jax.Device appartenenti alle sezioni attive, ordinati per slice_index.
  • inactive_slice_indices: un frozenset di indici di sezioni nell'allocazione che non partecipano alla mesh di calcolo.
  • available_inactive_slices: un frozenset di indici di sezioni inattive che il thread del monitor in background ha rilevato come integri e pronti per essere reintegrati.
  • total_slice_count e active_slice_count: il numero totale di sezioni allocate e il numero di sezioni attive.
  • default_device: dispositivo 0 di una sezione attiva, che elastic_retry imposta automaticamente come dispositivo JAX predefinito per ogni tentativo.

Puoi personalizzare il comportamento di ripetizione e scalabilità passando i seguenti argomenti a @elastic_manager.elastic_retry:

  • minimum_slice_count: il numero minimo di slice integri richiesti prima di avviare l'esecuzione iniziale o un tentativo di ripetizione. Se impostato su None (il valore predefinito), elastic_retry attende tutte le sezioni nell'allocazione (total_slice_count), operando in modalità di pausa e ripresa. Se impostato su un numero intero più piccolo (ad esempio 1), elastic_retry opera in modalità di ridimensionamento delle repliche.
  • poll_interval: l'intervallo in secondi tra i controlli di integrità delle sezioni eseguiti dal gestore dell'addestramento elastico (Manager) durante l'addestramento. Il valore predefinito è 10.
  • timeout: il numero massimo di secondi di attesa prima che le sezioni minimum_slice_count diventino attive prima di generare un TimeoutError. Il valore predefinito è None (nessun timeout).
  • pre_callback: un callback facoltativo che viene eseguito all'inizio di ogni tentativo dopo che il gestore aggiorna active_slice_indices e prima dell'esecuzione della funzione di loop di addestramento con wrapping.
  • on_elastic_event_callback: un callback facoltativo che viene eseguito dopo che elastic_retry rileva un errore di riduzione della sezione jax.errors.JaxRuntimeError, prima dell'inizio del tentativo di nuovo tentativo successivo. Puoi utilizzare questo callback per ripulire i checkpoint incompleti o reimpostare gli iteratori dei dati.
  • retry_policy: un (attempt: int, error: Exception) -> bool richiamabile che determina se continuare i tentativi dopo un evento elastico. Utilizza manager.ElasticRetryLimit(max_attempts) per limitare il numero totale di tentativi. Se omesso, elastic_retry riprova a tempo indeterminato.

Applica @elastic_manager.elastic_retry alla funzione del loop di addestramento, non a un singolo passaggio di addestramento. La decorazione di un singolo passaggio riavvia i controlli di integrità degli slice e il monitoraggio in background in ogni passaggio, il che aggiunge overhead e impedisce al gestore di rilevare gli slice che si sono uniti di nuovo.

In un evento elastico, JAX libera i buffer del dispositivo dal tentativo non riuscito dopo che lo stack frame si è srotolato e nessuna variabile fa riferimento a questi array. Evita di conservare i riferimenti agli array di dispositivi di un tentativo non riuscito all'interno di variabili globali o callback di lunga durata, in modo che la memoria venga rilasciata prima dell'inizio del tentativo successivo.

Snapshot in memoria con Orbax

La classe ocp.v1.training.pathways.Snapshotter (disponibile in orbax-checkpoint versione 0.12.6 e successive) mantiene un backup in memoria dello stato di addestramento nella memoria pinned_host tra le sezioni:

  • Snapshotter(*, replica_axis_index=0): inizializza lo snapshotter e specifica quale asse della mesh rappresenta le repliche di slice parallele ai dati. Tutti gli array JAX nello stato salvato devono essere replicati lungo questo asse della mesh in modo che gli slice sopravvissuti conservino una copia completa del modello e dello stato dell'ottimizzatore quando uno slice non funziona. Se lo stato contiene array di singoli dispositivi, replicali nella mesh prima di chiamare save.
  • save(step, state): trasferisce in modo asincrono state alla memoria pinned_host e lo suddivide in alberi per replica lungo replica_axis_index. Se un trasferimento di snapshot precedente è ancora in corso, save salta la nuova richiesta per evitare di bloccare il loop di addestramento.
  • load(abstract_state, *, reset_snapshot_state=True): esegue il probe delle repliche host salvate per identificare le sezioni sopravvissute, concatena le repliche integre e ripartisce lo stato negli sharding di destinazione specificati da abstract_state.
  • join(): blocca fino al completamento di qualsiasi operazione di snapshot in coda.
  • latest: restituisce i metadati (incluso step) per lo snapshot completato più di recente o None se non è stato completato alcuno snapshot.

Riduci lo sharding in caso di errore della sezione

Quando uno slice Cloud TPU non riesce o viene prerilasciato durante l'esecuzione, Pathways genera un jax.errors.JaxRuntimeError (ad esempio DATA_LOSS, DEADLINE_EXCEEDED, NOT_FOUND o INTERNAL). In una funzione decorata con @elastic_manager.elastic_retry, elastic_retry rileva questa eccezione e controlla elastic.is_error_due_to_slice_down(error):

  • Se l'errore non è causato da un evento di riduzione delle sezioni, elastic_retry genera nuovamente l'eccezione immediatamente.
  • Se l'errore è causato da un evento di riduzione, elastic_retry interrompe qualsiasi traccia attiva del profiler JAX, esegue on_elastic_event_callback e valuta retry_policy(attempt, error).
  • Prima di iniziare il tentativo successivo, elastic_retry chiama elastic.wait_for_slices una volta per eseguire il polling dello stato dello slice finché non sono attivi almeno minimum_slice_count slice. Quindi aggiorna elastic_manager.active_slice_indices ed esegue la funzione del ciclo di addestramento sugli slice sopravvissuti.

Aumenta lo sharding quando le sezioni si uniscono di nuovo

Quando il workload viene eseguito su un numero ridotto di sezioni in modalità di ridimensionamento delle repliche, il thread del monitor in background esegue periodicamente controlli di integrità su elastic_manager.inactive_slice_indices. Quando le sezioni riparate o ripianificate superano il controllo di integrità, il thread di monitoraggio aggiunge i relativi indici di sezione a elastic_manager.available_inactive_slices.

Quando elastic_manager.available_inactive_slices non è vuoto alla fine di un passaggio di addestramento, il loop di addestramento può eseguire lo scale up in loco senza perdere i progressi dell'addestramento:

  • Aggiorna le sezioni attive: aggiungi gli indici delle sezioni in elastic_manager.available_inactive_slices a elastic_manager.active_slice_indices. L'aggiornamento di active_slice_indices fa sì che elastic_manager incorpori le sezioni riunite in elastic_manager.active_devices e le cancelli da available_inactive_slices.
  • Ricostruisci la mesh e il loop di addestramento: ricostruisci la mesh del dispositivo da elastic_manager.active_devices e reinizializza il passaggio di addestramento e l'iteratore dei dati per la topologia espansa.
  • Esegui il resharding dello stato di addestramento: chiama jax.device_put per posizionare lo stato di addestramento corrente sui nuovi sharding della mesh senza eseguire il ripristino da uno snapshot.

Checkpointing multilivello

I job di addestramento su larga scala subiscono frequenti interruzioni e la scrittura o il ripristino dei checkpoint direttamente da e verso Cloud Storage può creare colli di bottiglia nell'avanzamento dell'addestramento. Il checkpointing multilivello riduce l'overhead del checkpointing e il tempo di recupero coordinando tre livelli di archiviazione su GKE:

  • Disco RAM locale: i worker Cloud TPU scrivono checkpoint ad alta frequenza in un volume CSI in memoria (multitier-checkpoint.csi.storage.gke.io) montato su ogni nodo worker. Questo volume persiste tra i riavvii dei pod sullo stesso nodo.
  • Replica peer in-cluster: il servizio di replica GKE replica gli shard dei checkpoint locali tra i worker Cloud TPU peer nel cluster.
  • Backup di Cloud Storage: il servizio di replica esegue il backup asincrono dei checkpoint locali in un bucket Cloud Storage con lo spazio dei nomi gerarchico abilitato, senza bloccare i passaggi di addestramento di Cloud TPU.

A differenza di JAX multi-controller, in cui ogni host Cloud TPU esegue il proprio script di addestramento, Pathways esegue un singolo controller sul pod pathways-head e invia il lavoro ai pod pathways-worker. Per leggere e scrivere shard di checkpoint direttamente sul disco RAM locale di ogni host Cloud TPU senza instradare i dati di checkpoint tramite il controller, Pathways utilizza Python in co-locazione. Ogni pod worker esegue un container colocated-python-sidecar insieme a pathways-worker ed entrambi i container montano il volume CSI di checkpoint multilivello e una directory di memoria condivisa (/tmp/sidecar). Durante l'inizializzazione e l'addestramento, Orbax invia la configurazione, i salvataggi e i ripristini dei checkpoint dal controller Pathways ai sidecar worker su ogni host Cloud TPU. Il checkpointing multilivello su Pathways supporta anche l'addestramento elastico durante lo scale up o lo scale down delle sezioni Cloud TPU attive.

Pathways supporta il checkpointing multilivello con MaxText. Per le istruzioni di configurazione, consulta la guida al checkpointing multilivello di MaxText.

Configura il workload Pathways

Puoi configurare un workload Pathways per il checkpointing multilivello utilizzando Cluster Toolkit (gcluster job submit) o configurando un manifest Pathways JobSet personalizzato.

Utilizza Cluster Toolkit

Quando invii un job con gcluster job submit --pathways, passa i tag immagine cloud-pathways corrispondenti insieme a --gke-mtc-enabled, --gke-mtc-ramdisk-dir e --pathways-colocated-python-sidecar-image:

IMAGE_REPO="us-docker.pkg.dev/cloud-tpu-v2-images/cloud-pathways"

gcluster job submit \
    --pathways \
    --pathways-gcs-location="gs://BUCKET_NAME/pathways-artifacts" \
    --pathways-server-image="${IMAGE_REPO}/server:jax-JAX_VERSION" \
    --pathways-proxy-server-image="${IMAGE_REPO}/proxy_server:jax-JAX_VERSION" \
    --pathways-colocated-python-sidecar-image="SIDECAR_IMAGE" \
    --gke-mtc-enabled \
    --gke-mtc-ramdisk-dir="/tmp/mtc_checkpoints" \
    ...

Sostituisci quanto segue:

  • BUCKET_NAME: il bucket Cloud Storage utilizzato per i file temporanei di Pathways.
  • JAX_VERSION: il tag della versione JAX (ad esempio 0.12.0.1) che corrisponde alle immagini del workload e del sidecar.
  • SIDECAR_IMAGE: l'URI dell'immagine container sidecar Python collocato.

Quando imposti questi flag, gcluster configura automaticamente quanto segue:

  • Passa --sidecar_name=external al container pathways-proxy.
  • Esegue il container colocated-python-sidecar in ogni pod worker e monta una directory /tmp/sidecar condivisa (--cloud_pathways_sidecar_shm_directory=/tmp/sidecar) sia su pathways-worker sia su colocated-python-sidecar.
  • Monta il volume CSI multitier-checkpoint.csi.storage.gke.io nel percorso specificato da --gke-mtc-ramdisk-dir sia in pathways-worker sia in colocated-python-sidecar nei pod worker, ma non nel pod pathways-head.

Utilizza un manifest JobSet di Pathways personalizzato

Se gestisci il tuo manifest Pathways JobSet anziché utilizzare gcluster, passa --sidecar_name=external a pathways-proxy. Nella specifica del pod worker, esegui colocated-python-sidecar in initContainers con restartPolicy: Always e monta sia il volume shared-memory sia il volume CSI multitier-checkpoint.csi.storage.gke.io su pathways-worker e colocated-python-sidecar:

initContainers:
- name: colocated-python-sidecar
  image: SIDECAR_IMAGE
  restartPolicy: Always
  env:
  - name: CLOUD_PATHWAYS_SIDECAR_SHM_DIRECTORY
    value: /tmp/sidecar
  volumeMounts:
  - name: shared-memory
    mountPath: /tmp/sidecar
  - name: checkpoint-mount
    mountPath: /tmp/mtc_checkpoints
containers:
- name: pathways-worker
  args:
  # ... existing pathways-worker args ...
  - --cloud_pathways_sidecar_shm_directory=/tmp/sidecar
  volumeMounts:
  - name: shared-memory
    mountPath: /tmp/sidecar
  - name: checkpoint-mount
    mountPath: /tmp/mtc_checkpoints
volumes:
- name: shared-memory
  emptyDir:
    medium: Memory
- name: checkpoint-mount
  csi:
    driver: multitier-checkpoint.csi.storage.gke.io

Sostituisci SIDECAR_IMAGE con l'URI dell'immagine container sidecar Python collocata.

Per i dettagli completi della configurazione del sidecar (tra cui la generazione di PathwaysJobSet e gli override facoltativi dei socket di dominio Unix), consulta Esegui il deployment di un JobSet Pathways con il sidecar. Per controllare i log di avvio del sidecar e della memoria condivisa dopo il deployment, consulta Verifica il deployment del sidecar.

Utilizza il checkpointing multilivello Orbax in un workload JAX personalizzato

In uno script di addestramento JAX personalizzato in esecuzione su Pathways, utilizza il pacchetto orbax.checkpoint.experimental.emergency.multi_tier_checkpointing e imposta use_colocated_python=True sia in initialize_multi_tier_checkpointing sia in ReplicatorCheckpointManagerOptions:

from etils import epath
import jax
import orbax.checkpoint as ocp
from orbax.checkpoint.experimental.emergency.multi_tier_checkpointing import (
    initialization,
    replicator_checkpoint_manager,
)
import pathwaysutils

pathwaysutils.initialize()

local_checkpoint_dir = epath.Path("/tmp/mtc_checkpoints")

# Initialize multi-tier checkpointing across worker sidecars.
# When using elastic training, pass the active slice devices to `devices`
# on initial setup and whenever the active slice count changes.
initialization.initialize_multi_tier_checkpointing(
    local_checkpoint_directory=local_checkpoint_dir,
    backup_interval_minutes=10,
    num_slices=num_slices,
    run_name=run_name,
    data_parallelism=data_parallelism,
    use_colocated_python=True,
    devices=jax.devices(),
)

options = replicator_checkpoint_manager.ReplicatorCheckpointManagerOptions(
    save_interval_steps=20,
    use_colocated_python=True,
)
checkpoint_manager = (
    replicator_checkpoint_manager.ReplicatorCheckpointManager(
        local_checkpoint_dir,
        options=options,
        global_mesh=mesh,
    )
)

# Restore from the latest checkpoint if one exists.
start_step = 1
latest_step = checkpoint_manager.latest_step()
if latest_step is not None:
  restore_args = jax.tree.map(
      lambda x: ocp.type_handlers.ArrayRestoreArgs(sharding=x.sharding),
      state,
  )
  restored = checkpoint_manager.restore(
      latest_step,
      args=ocp.args.Composite(
          state=ocp.args.PyTreeRestore(
              item=state,
              restore_args=restore_args,
          )
      ),
  )
  state = restored.state
  start_step = latest_step + 1

# Step 0 is reserved by the replicator service to indicate "no checkpoint".
for step in range(start_step, final_step + 1):
  state = jitted_train_step(state)
  checkpoint_manager.save(
      step,
      args=ocp.args.Composite(
          state=ocp.args.PyTreeSave(item=state)
      ),
  )

checkpoint_manager.wait_until_finished()
checkpoint_manager.close()

Hot-swap

La sostituzione a caldo è una funzionalità dell'API GKE JobSet che consente a un job con priorità più alta di assumere rapidamente il controllo delle risorse di un job con priorità più bassa, riducendo al minimo i tempi di inattività e accelerando il recupero.

Quando crei un JobSet, GKE pianifica il workload su più sezioni, come specificato nella configurazione di JobSet. Se si verifica un errore hardware su una o più sezioni, GKE contrassegna i pod interessati come non riusciti. Se il tuo cluster GKE ha una sezione di riserva che esegue un job con priorità più bassa, il controller JobSet rimappa il workload della sezione con errore dal job con priorità più alta a quella sezione di riserva. In genere, questa nuova mappatura richiede meno di un minuto.

Quando un JobSet viene riavviato, l'hot swap può verificarsi nelle seguenti situazioni:

  • Modalità predefinita: se sono disponibili sezioni Cloud TPU di riserva e inattive all'interno dello stesso cluster, lo scheduler di Kubernetes dà la priorità alla pianificazione dei job riavviati su queste sezioni, anziché attendere la riparazione delle sezioni con errori. Questo comportamento di pianificazione consente un recupero più rapido.
  • Workload eterogenei: nei cluster che eseguono più workload con una risorsa Kubernetes PriorityClass configurata, un JobSet riavviato può attivare uno scambio a caldo. Se l'affinità del job riavviato corrisponde alle risorse di un job con priorità inferiore, Kubernetes prerilascia il job con priorità inferiore in modo che il job con priorità superiore possa avviarsi senza attendere la riparazione dello slice. Ad esempio, puoi configurare i pod worker di Pathways con priorità diverse utilizzando una risorsa PriorityClass.

Per utilizzare le priorità nel cluster, definisci un manifest PriorityClass e salvalo come high-prior-job.yaml:

apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-prior-job
value: 2000
globalDefault: false
description: "This priority class should be used for high priority job."

Applica questo YAML al tuo cluster GKE e verifica che la classe di priorità esista:

kubectl apply -f high-prior-job.yaml
kubectl get priorityclass high-prior-job

Successivamente, collega la nuova classe di priorità al workload Pathways. Se invii il workload utilizzando Cluster Toolkit, passa --priority=high-prior-job al comando gcluster job submit, che imposta priorityClassName sia sui pod pathways-head che su quelli worker. Se scrivi il tuo manifest JobSet, imposta priorityClassName nel template del pod del job replicato worker che esegue il container pathways-worker:

replicatedJobs:
- name: worker
  template:
    spec:
      template:
        spec:
          priorityClassName: high-prior-job

Se hai creato il cluster utilizzando un progetto Cloud TPU di Cluster Toolkit con Pathways abilitato, il cluster include già le classi di priorità very-low, low, medium, high e very-high. Puoi passare una di queste classi a --priority anziché crearne una tua.

Esegui la pulizia

Per evitare che ti vengano addebitati costi continui o di lasciare risorse di pianificazione inutilizzate nel tuo cluster, elimina le risorse che hai creato in questa guida:

  1. Elimina i tuoi percorsi JobSet:

    kubectl delete jobset JOBSET_NAME
    

    Sostituisci JOBSET_NAME con il valore metadata.name di JobSet.

  2. (Facoltativo) Elimina il PriorityClass personalizzato se ne hai creato uno:

    kubectl delete priorityclass high-prior-job
    
  3. (Facoltativo) Se nessun altro workload nel cluster utilizza il checkpoint multilivello, elimina la risorsa personalizzata CheckpointConfiguration (l'eliminazione disinstalla il driver CSI del checkpoint multilivello dai nodi):

    kubectl delete checkpointconfiguration CHECKPOINT_CONFIG_NAME
    

    Sostituisci CHECKPOINT_CONFIG_NAME con il valore metadata.name della risorsa CheckpointConfiguration.

Passaggi successivi