En esta página, se explica cómo los ingenieros de aprendizaje automático pueden configurar funciones de resiliencia para las cargas de trabajo de Pathways en Google Kubernetes Engine (GKE) de modo que los trabajos de entrenamiento a gran escala puedan recuperarse de interrupciones planificadas y fallas de hardware no planificadas.
Pathways proporciona beneficios de resiliencia de las siguientes maneras:
- Suspender y reanudar: Permite que tu carga de trabajo tolere interrupciones planificadas, como avisos de interrupción, sin necesidad de un código personalizado de control de interrupciones.
- Entrenamiento elástico: Permite que tu carga de trabajo tolere fallas de hardware no planificadas sin que falle el cliente con la lógica de recuperación en tu código de entrenamiento.
- Puntos de control de varios niveles: Permite que tu carga de trabajo guarde puntos de control locales y replicados por pares de alta frecuencia en los trabajadores de Cloud TPU con Python ubicado en el mismo lugar, con copias de seguridad asíncronas de Cloud Storage para reducir el tiempo de recuperación.
- Intercambio en caliente: Permite que una carga de trabajo de
JobSetde GKE de mayor prioridad asuma rápidamente el control de las porciones de Cloud TPU de repuesto o de menor prioridad cuando se produce una falla de hardware.
Antes de comenzar
Completa los siguientes requisitos previos:
- Configura Cluster Toolkit.
- Instala las herramientas de Kubernetes.
- Instala Google Cloud CLI.
- Habilita la API de Kubernetes Engine.
- Crea un clúster de GKE con Pathways.
- Crea un bucket de Cloud Storage para los archivos temporales de Pathways.
Si usas el entrenamiento elástico, instala los siguientes paquetes en la imagen de contenedor de tu carga de trabajo:
pathwaysutils- Orbax (
orbax-checkpoint):>= 0.12.6(obligatorio para las instantáneas en memoria conocp.v1.training.pathways.Snapshotter) - Grain (
grain): Es obligatorio si usasgrain.experimental.ElasticIterator.
Si usas la creación de puntos de control de varios niveles, también completa los siguientes requisitos previos:
- Sigue las instrucciones de Entrena modelos de aprendizaje automático a gran escala en GKE con puntos de control de varios niveles para configurar tu clúster de GKE para los puntos de control de varios niveles:
- Habilita los complementos de puntos de control de varios niveles (
HighScaleCheckpointing) y Cloud Storage FUSE (GcsFuseCsiDriver), junto con Workload Identity Federation for GKE, en tu clúster. - Crea un bucket de Cloud Storage con el espacio de nombres jerárquico habilitado.
- Otorga el rol de Identity and Access Management (IAM) de Usuario de objetos de almacenamiento (
roles/storage.objectUser) en el bucket a la cuenta de servicio de Kubernetes de creación de puntos de control de varios niveles de GKE (gke-checkpointing-multitier-nodeengke-managed-checkpointing). - Implementa un recurso personalizado
CheckpointConfigurationque especifique tu bucket de Cloud Storage, el selector de nodos de Cloud TPU y el tamaño del volumen en la memoria (inMemoryVolumeSize).
- Habilita los complementos de puntos de control de varios niveles (
- Compila y envía una imagen de contenedor de sidecar de Python 3.12 ubicado en el mismo lugar
siguiendo las instrucciones de Ejecuta Python ubicado en el mismo lugar con
Pathways, por
ejemplo, según el
sample_sidecar.dockerfileenpathways-utils. Si tu archivorequirements.txtoDockerfileinstala paquetes desde URLs de Git, primero instalagitconapt-get, ya que la imagen base reducida omitegit. Usa Python 3.12 y las versiones dejaxyjaxlibque coincidan en tus imágenes de carga de trabajo y de archivo adicional, que cumplan con estas versiones mínimas:- Orbax (
orbax-checkpoint):>= 0.12.4 - JAX (
jaxyjaxlib):>= 0.10.1
- Orbax (
Suspensión y reanudación
Por lo general, GKE envía una notificación de interrupción a un Pod acelerador antes de interrumpirlo. Pathways habilita la tolerancia a la interrupción de forma predeterminada en todas las implementaciones de Cloud, y los trabajos del acelerador de Pathways escuchan estos avisos.
Cuando llega un aviso de interrupción, Pathways primero determina si puede guardar y restablecer la carga de trabajo. Si es posible, Pathways intenta suspender tu carga de trabajo de ML escribiendo su estado actual en el almacenamiento persistente, como Cloud Storage, antes de que GKE expulse tus trabajos de acelerador. Cuando GKE vuelve a programar tus trabajos más adelante, Pathways reanuda tu carga de trabajo de AA leyendo su estado persistente.
Si la carga de trabajo no se puede restablecer, Pathways cierra el trabajo del acelerador afectado y genera un jax.errors.JaxRuntimeError en el proceso del cliente de un solo controlador si se configura el entrenamiento elástico. Si no se configura el entrenamiento elástico, GKE reinicia toda la carga de trabajo según la política de reinicio JobSet.
Las cargas de trabajo de ML típicas definidas con JAX se basan en componentes de XLA de Pathways sin estado, que se pueden restablecer con una instantánea de memoria de alto ancho de banda (HBM). Ciertas cargas de trabajo de AA, como las que se definen con la API de Python de JAX colocada, dependen de componentes de Pathways con estado y no se pueden restablecer.
Entrenamiento elástico
El entrenamiento elástico permite que tu trabajo de entrenamiento continúe cuando se producen fallas de hardware o interrupciones de porciones, sin reiniciar toda la carga de trabajo. En un trabajo de entrenamiento de varias porciones, Pathways mantiene activos el proceso del cliente de un solo controlador y las porciones de Cloud TPU en buen estado cuando una porción individual deja de estar disponible.
El entrenamiento elástico combina las capacidades del sistema de Pathways con la lógica de recuperación en tu código de entrenamiento:
- Detección de fallas: Cuando se produce una falla de hardware o una interrupción en una
porción de Cloud TPU, Pathways anula la asignación de la porción afectada y genera un
jax.errors.JaxRuntimeErrorla próxima vez que tu carga de trabajo acceda a los datos de esa porción. Debido a que el proceso del cliente permanece activo, tu código puede detectar este error, volver a configurar tus recursos y continuar con el entrenamiento. - Modos de recuperación: La clase
pathwaysutils.elastic.manager.Managery su decoradorelastic_retryadmiten dos estrategias de recuperación:- Detener y reanudar: Si configuras
minimum_slice_countcomoNoneo como el recuento total de porciones, el entrenamiento se detiene cuando falla una porción y se reanuda después de que todas las porciones vuelven a estar en buen estado. Debido a que el recuento de porciones no cambia entre los intentos, tu carga de trabajo puede reutilizar su malla de dispositivos existente y los ejecutables compilados. - Cambio de tamaño de la réplica: Si configuras
minimum_slice_countcomo un valor menor que el recuento total de porciones, el entrenamiento continúa en las porciones activas restantes cuando falla una porción. Tu carga de trabajo vuelve a compilar la malla del dispositivo y vuelve a compilar para la topología más pequeña. Un subproceso de supervisión en segundo plano verifica periódicamente los segmentos inactivos y registra los segmentos que vuelven a estar en buen estado enelastic_manager.available_inactive_slices. Luego, tu bucle de entrenamiento puede reconstruir la malla de dispositivos con los sectores de reemplazo, reinicializar para la topología expandida y colocar el estado actual en la malla nueva.
- Detener y reanudar: Si configuras
- Recuperación de estado: Para reanudar el entrenamiento después de un evento elástico, tu carga de trabajo
restablece los parámetros del modelo, el estado del optimizador y el estado del iterador de datos con
instantáneas en la memoria.
ocp.v1.training.pathways.Snapshotterenorbax.checkpointcopia de forma asíncrona el estado replicado de la HBM de Cloud TPU a la memoria de la CPU depinned_hosten cada porción. Durante la recuperación,Snapshotterreconstruye el estado a partir de las réplicas de host sobrevivientes y lo vuelve a fragmentar directamente en la malla de Cloud TPU activa sin leer desde el almacenamiento remoto.
Habilita la elasticidad en el servidor proxy de Pathways
Para habilitar los conjuntos de dispositivos elásticos en Pathways en GKE, agrega la
marca --num_elastic_instances al campo args del contenedor pathways-proxy
en tu manifiesto de JobSet y especifica la cantidad de porciones de Cloud TPU
elásticas en tu carga de trabajo:
- 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
Reemplaza lo siguiente:
JAX_VERSION: Es la etiqueta de la versión de JAX (por ejemplo,0.12.0.1) que coincide con las imágenes del servidor y de la carga de trabajo de Pathways.BUCKET_NAME: Es el bucket de Cloud Storage que se usa para los archivos temporales de Pathways.NUM_SLICES: Es la cantidad de porciones de Cloud TPU en tu carga de trabajo.
Filtra los dispositivos activos y compila la malla de dispositivos
En una carga de trabajo de Pathways, jax.devices() devuelve una lista estática de todos los dispositivos
desde el inicio y no se actualiza si una porción falla o se recupera. Cuando uses
el entrenamiento elástico, usa elastic_manager.active_devices para que la malla de dispositivos
y el tamaño del lote solo usen porciones en buen estado y activas:
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"))
Cuando cambia la cantidad de porciones activas en el modo de cambio de tamaño de réplica, usa un cargador de datos
elástico, como grain.experimental.ElasticIterator. Los iteradores de datos estándar por host guardan el estado por host y no se pueden restablecer en una cantidad diferente de hosts. En cambio, ElasticIterator hace un seguimiento de una sola posición del conjunto de datos global que puedes restablecer en cualquier cantidad de porciones activas.
Bucle de entrenamiento elástico
Un bucle de entrenamiento elástico coordina la supervisión de porciones, la recuperación ante fallas y
la creación de instantáneas en la memoria combinando manager.Manager, elastic_retry y
Snapshotter en la memoria de Orbax, como se muestra en el siguiente ejemplo:
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 el administrador elástico y el comportamiento de reintento
Crea una instancia de manager.Manager(devices=None) una vez por proceso. Si omites
devices, el administrador usa jax.devices() y agrupa los dispositivos por su
atributo slice_index.
La instancia Manager expone las siguientes propiedades para inspeccionar la topología del clúster
durante el entrenamiento:
slice_to_devices: Es una asignación de cadaslice_indexa la secuencia de objetosjax.Deviceque pertenecen a esa porción.all_slice_indices: Es unfrozensetde todos los índices de porciones de la asignación.active_slice_indices: Es unfrozensetde índices de porciones que participan en la malla de procesamiento activa.active_devices: Es una lista de objetosjax.Deviceque pertenecen a los segmentos activos, ordenados porslice_index.inactive_slice_indices: Es unfrozensetde índices de porciones en la asignación que no participan en la malla de procesamiento.available_inactive_slices: Es unfrozensetde índices de porciones inactivas que el subproceso del monitor en segundo plano detectó como en buen estado y listo para volver a unirse.total_slice_countyactive_slice_count: Es la cantidad total de porciones asignadas y la cantidad de porciones activas.default_device: Es el dispositivo0de una porción activa, queelastic_retryestablece automáticamente como el dispositivo JAX predeterminado para cada intento.
Puedes personalizar el comportamiento de reintento y escalamiento pasando los siguientes argumentos
a @elastic_manager.elastic_retry:
minimum_slice_count: Es la cantidad mínima de porciones en buen estado que se requieren antes de iniciar la ejecución inicial o un intento de reintento. Si se establece enNone(el valor predeterminado),elastic_retryespera a que se completen todas las porciones de la asignación (total_slice_count) y opera en modo de pausa y reanudación. Si se establece en un número entero más pequeño (como1),elastic_retryopera en el modo de cambio de tamaño de la réplica.poll_interval: Es el intervalo en segundos entre las verificaciones de estado de las porciones que realiza el administrador de entrenamiento elástico (Manager) durante el entrenamiento. La configuración predeterminada es10.timeout: Es la cantidad máxima de segundos que se debe esperar para que las porciones deminimum_slice_countse activen antes de generar unTimeoutError. La configuración predeterminada esNone(sin tiempo de espera).pre_callback: Es una devolución de llamada opcional que se ejecuta al comienzo de cada intento después de que el administrador actualizaactive_slice_indicesy antes de que se ejecute la función de bucle de entrenamiento unida.on_elastic_event_callback: Es una devolución de llamada opcional que se ejecuta después de queelastic_retrydetecta unjax.errors.JaxRuntimeErrorde reducción, antes de que comience el siguiente intento de reintento. Puedes usar esta devolución de llamada para limpiar los puntos de control incompletos o restablecer los iteradores de datos.retry_policy: Es un(attempt: int, error: Exception) -> boolque se puede llamar y que determina si se debe seguir reintentando después de un evento elástico. Usamanager.ElasticRetryLimit(max_attempts)para limitar la cantidad total de intentos. Si se omite,elastic_retryreintenta de forma indefinida.
Aplica @elastic_manager.elastic_retry a tu función de bucle de entrenamiento, no a un
paso de entrenamiento individual. Decorar un solo paso reinicia las verificaciones de estado de las porciones y la supervisión en segundo plano en cada paso, lo que agrega sobrecarga y evita que el administrador detecte las porciones que se volvieron a unir.
En un evento elástico, JAX libera los búferes del dispositivo del intento fallido después de que se desenrolla el marco de pila y ninguna variable hace referencia a esos arrays. Evita mantener referencias a arrays de dispositivos de un intento fallido dentro de variables globales o devoluciones de llamada de larga duración para que se libere memoria antes de que comience el siguiente intento.
Instantáneas en memoria con Orbax
La clase ocp.v1.training.pathways.Snapshotter (disponible en
la versión 0.12.6 de orbax-checkpoint y posteriores) mantiene una copia de seguridad en la memoria de
tu estado de entrenamiento en la memoria de pinned_host en todas las porciones:
Snapshotter(*, replica_axis_index=0): Inicializa el generador de instantáneas y especifica qué eje de malla representa las réplicas de porciones paralelas de datos. Todos los arrays de JAX en el estado guardado se deben replicar a lo largo de este eje de malla para que las porciones sobrevivientes conserven una copia completa del estado del modelo y del optimizador cuando falle una porción. Si tu estado contiene arrays de un solo dispositivo, replícalos en la malla antes de llamar asave.save(step, state): Transfiere de forma asíncronastatea la memoriapinned_hosty lo divide en árboles por réplica a lo largo dereplica_axis_index. Si una transferencia de instantánea anterior aún está en curso,saveomite la solicitud nueva para evitar que se detenga el bucle de entrenamiento.load(abstract_state, *, reset_snapshot_state=True): Sondea las réplicas de host guardadas para identificar las porciones sobrevivientes, concatena las réplicas en buen estado y vuelve a fragmentar el estado en las fragmentaciones de destino especificadas porabstract_state.join(): Bloquea hasta que se complete cualquier operación de instantánea en cola.latest: Devuelve los metadatos (incluidostep) de la instantánea completada más recientemente, oNonesi no se completó ninguna instantánea.
Reduce la fragmentación en caso de falla de la porción
Cuando una porción de Cloud TPU falla o se interrumpe durante la ejecución, Pathways
genera un jax.errors.JaxRuntimeError (como DATA_LOSS, DEADLINE_EXCEEDED,
NOT_FOUND o INTERNAL). En una función decorada con
@elastic_manager.elastic_retry, elastic_retry detecta esta excepción y
verifica elastic.is_error_due_to_slice_down(error):
- Si el error no se debe a un evento de reducción,
elastic_retryvuelve a generar la excepción de inmediato. - Si el error se produce por un evento de reducción de porciones,
elastic_retrydetiene cualquier seguimiento activo del generador de perfiles de JAX, ejecutaon_elastic_event_callbacky evalúaretry_policy(attempt, error). - Antes de comenzar el siguiente intento,
elastic_retryllama aelastic.wait_for_slicesuna vez para sondear el estado de los segmentos hasta que al menosminimum_slice_countsegmentos estén activos. Luego, actualizaelastic_manager.active_slice_indicesy ejecuta la función de bucle de entrenamiento en las porciones restantes.
Aumenta la fragmentación cuando se vuelven a unir los segmentos
Cuando tu carga de trabajo se ejecuta en una cantidad reducida de porciones en el modo de cambio de tamaño de réplica,
el subproceso de supervisión en segundo plano ejecuta verificaciones de estado periódicas en
elastic_manager.inactive_slice_indices. Cuando las porciones reparadas o reprogramadas
aprueban la verificación de estado, el subproceso de supervisión agrega sus índices de porción a
elastic_manager.available_inactive_slices.
Cuando elastic_manager.available_inactive_slices no está vacío al final de un
paso de entrenamiento, tu bucle de entrenamiento puede volver a escalar verticalmente sin perder
el progreso del entrenamiento:
- Actualiza los segmentos activos: Agrega los índices de segmentos de
elastic_manager.available_inactive_slicesaelastic_manager.active_slice_indices. Cuando se actualizaactive_slice_indices,elastic_managerincorpora los sectores que se volvieron a unir enelastic_manager.active_devicesy los borra deavailable_inactive_slices. - Vuelve a compilar la malla y el bucle de entrenamiento: Vuelve a compilar la malla del dispositivo desde
elastic_manager.active_devicesy reinicializa el paso de entrenamiento y el iterador de datos para la topología expandida. - Vuelve a fragmentar el estado de entrenamiento: Llama a
jax.device_putpara colocar el estado de entrenamiento actual en las nuevas fragmentaciones de malla sin restablecer desde una instantánea.
Puntos de control de varios niveles
Los trabajos de entrenamiento a gran escala experimentan interrupciones frecuentes, y escribir o restablecer puntos de control directamente desde y hacia Cloud Storage puede generar cuellos de botella en el progreso del entrenamiento. Los puntos de control de varios niveles reducen la sobrecarga de los puntos de control y el tiempo de recuperación coordinando tres niveles de almacenamiento en GKE:
- Disco de RAM local: Los trabajadores de Cloud TPU escriben puntos de control de alta frecuencia
en un volumen de CSI en la memoria
(
multitier-checkpoint.csi.storage.gke.io) activado en cada nodo trabajador. Este volumen persiste en los reinicios del Pod en el mismo nodo. - Replicación de pares en el clúster: El servicio de replicador de GKE replica fragmentos de puntos de control locales en los trabajadores de Cloud TPU pares en el clúster.
- Copia de seguridad de Cloud Storage: El servicio de replicador crea copias de seguridad de forma asíncrona de los puntos de control locales en un bucket de Cloud Storage con el espacio de nombres jerárquico habilitado, sin bloquear los pasos de entrenamiento de Cloud TPU.
A diferencia de JAX de varios controladores, en el que cada host de Cloud TPU ejecuta su propia
secuencia de comandos de entrenamiento, Pathways ejecuta un solo controlador en el Pod de pathways-head
y envía el trabajo a los Pods de pathways-worker. Para leer y escribir fragmentos de puntos de control
directamente en el disco RAM local de cada host de Cloud TPU sin enrutar
los datos de los puntos de control a través del controlador, Pathways usa
Python ubicado en el mismo lugar.
Cada Pod de worker ejecuta un contenedor de colocated-python-sidecar junto con
pathways-worker, y ambos contenedores activan el volumen de CSI de puntos de control de varios niveles
y un directorio de memoria compartida (/tmp/sidecar). Durante la inicialización y
el entrenamiento, Orbax envía la configuración, los guardados y las restauraciones de los puntos de control desde el
controlador de Pathways a los sidecars de trabajadores en cada host de Cloud TPU.
La creación de puntos de control de varios niveles en Pathways también admite
el entrenamiento elástico cuando se reducen o aumentan las porciones activas de Cloud TPU.
Pathways admite la creación de puntos de control de varios niveles con MaxText. Para obtener instrucciones de configuración, consulta la guía de puntos de control de varios niveles de MaxText.
Configura tu carga de trabajo de Pathways
Puedes configurar una carga de trabajo de Pathways para la creación de puntos de control de varios niveles con
Cluster Toolkit (gcluster job submit) o con un manifiesto de JobSet
de Pathways personalizado.
Usa Cluster Toolkit
Cuando envíes un trabajo con gcluster job submit --pathways, pasa las etiquetas de imagen
cloud-pathways que coincidan junto con --gke-mtc-enabled,
--gke-mtc-ramdisk-dir y --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" \
...
Reemplaza lo siguiente:
BUCKET_NAME: Es el bucket de Cloud Storage que se usa para los archivos temporales de Pathways.JAX_VERSION: Es la etiqueta de la versión de JAX (por ejemplo,0.12.0.1) que coincide con las imágenes de tu carga de trabajo y de sidecar.SIDECAR_IMAGE: Es el URI de tu imagen de contenedor sidecar de Python coubicada.
Cuando configuras estas marcas, gcluster establece automáticamente lo siguiente:
- Pasa
--sidecar_name=externalal contenedorpathways-proxy. - Ejecuta el contenedor
colocated-python-sidecaren cada Podworkery activa un directorio/tmp/sidecarcompartido (--cloud_pathways_sidecar_shm_directory=/tmp/sidecar) enpathways-workerycolocated-python-sidecar. - Activa el volumen de CSI de
multitier-checkpoint.csi.storage.gke.ioen la ruta de acceso especificada por--gke-mtc-ramdisk-direnpathways-workerycolocated-python-sidecaren los Pods deworker, pero no en el Pod depathways-head.
Usa un manifiesto de JobSet de Pathways personalizado
Si administras tu propio manifiesto de JobSet de Pathways en lugar de usar gcluster,
pasa --sidecar_name=external a pathways-proxy. En la especificación del Pod de trabajador,
ejecuta colocated-python-sidecar en initContainers con
restartPolicy: Always y activa el volumen shared-memory y el
volumen CSI multitier-checkpoint.csi.storage.gke.io en pathways-worker y
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
Reemplaza SIDECAR_IMAGE por el
URI de la imagen de contenedor de sidecar de Python coubicada.
Para obtener detalles completos de la configuración del archivo adicional (incluida la generación de PathwaysJobSet
y las anulaciones opcionales de sockets de dominio de Unix), consulta Implementa un JobSet de Pathways con
el
archivo adicional.
Para verificar los registros de inicio del archivo adicional y de la memoria compartida después de la implementación, consulta Verifica
la implementación
del archivo adicional.
Usa los puntos de control de varios niveles de Orbax en una carga de trabajo de JAX personalizada
En una secuencia de comandos de entrenamiento de JAX personalizada que se ejecuta en Pathways, usa el
paquete orbax.checkpoint.experimental.emergency.multi_tier_checkpointing y
establece use_colocated_python=True en initialize_multi_tier_checkpointing
y 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()
Intercambio en caliente
El intercambio en caliente es una función de la API de JobSet de GKE que permite que un
trabajo de mayor prioridad se apropie rápidamente de los recursos de un trabajo de menor prioridad,
lo que minimiza el tiempo de inactividad y acelera la recuperación.
Cuando creas un JobSet, GKE programa la carga de trabajo en
varias porciones, como se especifica en la configuración de JobSet. Si se produce una falla de hardware
en uno o más segmentos, GKE marca los Pods afectados
como fallidos. Si tu clúster de GKE tiene una porción de repuesto que ejecuta un
trabajo de menor prioridad, el controlador JobSet reasigna la carga de trabajo de la porción con errores
del trabajo de mayor prioridad a esa porción de repuesto. Esta reasignación suele
tardar menos de un minuto.
Cuando se reinicia un JobSet, el intercambio en caliente puede ocurrir en las siguientes situaciones:
- Modo predeterminado: Si hay porciones de Cloud TPU inactivas y de repuesto disponibles en el mismo clúster, el programador de Kubernetes prioriza la programación de los trabajos reiniciados en estas porciones en lugar de esperar a que se reparen las porciones con errores. Este comportamiento de programación proporciona una recuperación más rápida.
- Cargas de trabajo heterogéneas: En los clústeres que ejecutan varias cargas de trabajo con un
recurso
PriorityClassde Kubernetes configurado, unJobSetreiniciado puede activar un intercambio en caliente. Si la afinidad del trabajo reiniciado coincide con los recursos de un trabajo de menor prioridad, Kubernetes interrumpe el trabajo de menor prioridad para que el trabajo de mayor prioridad pueda iniciarse sin esperar a que se repare la porción. Por ejemplo, puedes configurar los Pods de trabajadores de Pathways con diferentes prioridades usando un recursoPriorityClass.
Para usar prioridades en tu clúster, define un manifiesto PriorityClass y guárdalo
como 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."
Aplica este YAML a tu clúster de GKE y verifica que exista la clase de prioridad:
kubectl apply -f high-prior-job.yaml
kubectl get priorityclass high-prior-job
A continuación, adjunta la nueva clase de prioridad a tu carga de trabajo de Pathways. Si envías
tu carga de trabajo con Cluster Toolkit, pasa
--priority=high-prior-job al comando gcluster job submit, que establece
priorityClassName en los Pods pathways-head y worker. Si escribes
tu propio manifiesto de JobSet, establece priorityClassName en la plantilla de Pod del
trabajo replicado de worker que ejecuta el contenedor de pathways-worker:
replicatedJobs:
- name: worker
template:
spec:
template:
spec:
priorityClassName: high-prior-job
Si creaste tu clúster con un plano de Cloud TPU del kit de herramientas de clústeres
con Pathways habilitado, el clúster ya incluye
las clases de prioridad very-low, low, medium, high y very-high. Puedes
pasar una de esas clases a --priority en lugar de crear la tuya.
Realiza una limpieza
Para evitar que se generen cargos continuos o dejar recursos de programación sin usar en tu clúster, borra los recursos que creaste en esta guía:
Borra tus Pathways
JobSet:kubectl delete jobset JOBSET_NAMEReemplaza
JOBSET_NAMEpor el valor demetadata.namede tuJobSet.Opcional: Borra el
PriorityClasspersonalizado si creaste uno:kubectl delete priorityclass high-prior-jobOpcional: Si ninguna otra carga de trabajo del clúster usa la creación de puntos de control de varios niveles, borra tu recurso personalizado
CheckpointConfiguration(si lo borras, se desinstalará el controlador de CSI de creación de puntos de control de varios niveles de los nodos):kubectl delete checkpointconfiguration CHECKPOINT_CONFIG_NAMEReemplaza
CHECKPOINT_CONFIG_NAMEpor el valormetadata.namede tu recursoCheckpointConfiguration.
¿Qué sigue?
- Crea un clúster de GKE con Pathways
- Ejecuta una carga de trabajo por lotes con Pathways
- Modo interactivo de Pathways
- Porta cargas de trabajo de JAX a Pathways
- Ejecuta Python ubicado en el mismo lugar con Pathways
- Soluciona problemas de Pathways en Cloud
- Entrena modelos de aprendizaje automático a gran escala en GKE con puntos de control de varios niveles
- Guía de puntos de control de varios niveles de MaxText
- Usa puntos de control de varios niveles para trabajos de entrenamiento de IA grandes