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
JobSetcon 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:
- Configura Cluster Toolkit.
- Installa gli strumenti Kubernetes.
- Installa Google Cloud CLI.
- Abilita l'API Kubernetes Engine.
- Crea un cluster GKE con Pathways.
- Crea un bucket Cloud Storage per i file temporanei di Pathways.
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 conocp.v1.training.pathways.Snapshotter) - Grain (
grain): obbligatorio se utilizzigrain.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-nodeingke-managed-checkpointing). - Esegui il deployment di una risorsa personalizzata
CheckpointConfigurationspecificando il tuo bucket Cloud Storage, il selettore di nodi Cloud TPU e le dimensioni del volume in memoria (inMemoryVolumeSize).
- Abilita i componenti aggiuntivi Multi-Tier Checkpointing (
- 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.dockerfileinpathways-utils. Se il filerequirements.txtoDockerfileinstalla pacchetti da URL Git, installa primagitconapt-getperché l'immagine di base slim omettegit. Utilizza Python 3.12 e le versionijaxejaxlibcorrispondenti nelle immagini del workload e del sidecar, rispettando queste versioni minime:- Orbax (
orbax-checkpoint):>= 0.12.4 - JAX (
jaxejaxlib):>= 0.10.1
- Orbax (
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.JaxRuntimeErrorla 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.Managere il relativo decoratoreelastic_retrysupportano due strategie di recovery:- Metti in pausa e riprendi: se imposti
minimum_slice_countsuNoneo 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_countsu 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 inelastic_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.
- Metti in pausa e riprendi: se imposti
- 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.Snapshotterinorbax.checkpointcopia in modo asincrono lo stato replicato dalla memoria HBM di Cloud TPU alla memoria della CPUpinned_hostsu ogni sezione. Durante il recupero,Snapshotterricostruisce 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 esempio0.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 ognislice_indexalla sequenza di oggettijax.Deviceche appartengono a quella sezione.all_slice_indices: unfrozensetdi tutti gli indici delle sezioni nell'allocazione.active_slice_indices: unfrozensetdi indici di sezioni che partecipano al mesh di calcolo attivo.active_devices: un elenco di oggettijax.Deviceappartenenti alle sezioni attive, ordinati perslice_index.inactive_slice_indices: unfrozensetdi indici di sezioni nell'allocazione che non partecipano alla mesh di calcolo.available_inactive_slices: unfrozensetdi indici di sezioni inattive che il thread del monitor in background ha rilevato come integri e pronti per essere reintegrati.total_slice_counteactive_slice_count: il numero totale di sezioni allocate e il numero di sezioni attive.default_device: dispositivo0di una sezione attiva, cheelastic_retryimposta 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 suNone(il valore predefinito),elastic_retryattende tutte le sezioni nell'allocazione (total_slice_count), operando in modalità di pausa e ripresa. Se impostato su un numero intero più piccolo (ad esempio1),elastic_retryopera 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 sezioniminimum_slice_countdiventino attive prima di generare unTimeoutError. Il valore predefinito èNone(nessun timeout).pre_callback: un callback facoltativo che viene eseguito all'inizio di ogni tentativo dopo che il gestore aggiornaactive_slice_indicese prima dell'esecuzione della funzione di loop di addestramento con wrapping.on_elastic_event_callback: un callback facoltativo che viene eseguito dopo cheelastic_retryrileva un errore di riduzione della sezionejax.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) -> boolrichiamabile che determina se continuare i tentativi dopo un evento elastico. Utilizzamanager.ElasticRetryLimit(max_attempts)per limitare il numero totale di tentativi. Se omesso,elastic_retryriprova 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 chiamaresave.save(step, state): trasferisce in modo asincronostatealla memoriapinned_hoste lo suddivide in alberi per replica lungoreplica_axis_index. Se un trasferimento di snapshot precedente è ancora in corso,savesalta 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 daabstract_state.join(): blocca fino al completamento di qualsiasi operazione di snapshot in coda.latest: restituisce i metadati (inclusostep) per lo snapshot completato più di recente oNonese 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_retrygenera nuovamente l'eccezione immediatamente. - Se l'errore è causato da un evento di riduzione,
elastic_retryinterrompe qualsiasi traccia attiva del profiler JAX, esegueon_elastic_event_callbacke valutaretry_policy(attempt, error). - Prima di iniziare il tentativo successivo,
elastic_retrychiamaelastic.wait_for_slicesuna volta per eseguire il polling dello stato dello slice finché non sono attivi almenominimum_slice_countslice. Quindi aggiornaelastic_manager.active_slice_indicesed 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_slicesaelastic_manager.active_slice_indices. L'aggiornamento diactive_slice_indicesfa sì cheelastic_managerincorpori le sezioni riunite inelastic_manager.active_devicese le cancelli daavailable_inactive_slices. - Ricostruisci la mesh e il loop di addestramento: ricostruisci la mesh del dispositivo da
elastic_manager.active_devicese reinizializza il passaggio di addestramento e l'iteratore dei dati per la topologia espansa. - Esegui il resharding dello stato di addestramento: chiama
jax.device_putper 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 esempio0.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=externalal containerpathways-proxy. - Esegue il container
colocated-python-sidecarin ogni podworkere monta una directory/tmp/sidecarcondivisa (--cloud_pathways_sidecar_shm_directory=/tmp/sidecar) sia supathways-workersia sucolocated-python-sidecar. - Monta il volume CSI
multitier-checkpoint.csi.storage.gke.ionel percorso specificato da--gke-mtc-ramdisk-dirsia inpathways-workersia incolocated-python-sidecarnei podworker, ma non nel podpathways-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
PriorityClassconfigurata, unJobSetriavviato 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 risorsaPriorityClass.
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:
Elimina i tuoi percorsi
JobSet:kubectl delete jobset JOBSET_NAMESostituisci
JOBSET_NAMEcon il valoremetadata.namediJobSet.(Facoltativo) Elimina il
PriorityClasspersonalizzato se ne hai creato uno:kubectl delete priorityclass high-prior-job(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_NAMESostituisci
CHECKPOINT_CONFIG_NAMEcon il valoremetadata.namedella risorsaCheckpointConfiguration.
Passaggi successivi
- Crea un cluster GKE con Pathways
- Esegui un workload batch con Pathways
- Modalità interattiva di Pathways
- Porta i workload JAX su Pathways
- Esegui Python in co-locazione con Pathways
- Risolvi i problemi relativi ai percorsi su Cloud
- Addestra modelli di machine learning su larga scala su GKE con il checkpointing multilivello
- Guida al checkpointing multilivello di MaxText
- Utilizzo del checkpointing a più livelli per job di addestramento AI di grandi dimensioni