透過 Pathways 進行彈性訓練

本頁面說明機器學習工程師如何為 Google Kubernetes Engine (GKE) 上的 Pathways 工作負載設定韌性功能,讓大規模訓練工作能從預定中斷和非預期的硬體故障中復原。

Pathways 透過下列方式提供復原力優勢:

  • 暫停與恢復:讓工作負載容許預定的中斷,例如先占通知,而不需要自訂先占處理程式碼。
  • 彈性訓練:在訓練程式碼中使用復原邏輯,讓工作負載容許非預期的硬體故障,而不會導致用戶端當機。
  • 多層級查核點:工作負載可使用共置 Python,在 Cloud TPU 工作站之間儲存高頻率的本機和對等複製查核點,並透過非同步 Cloud Storage 備份縮短復原時間。
  • 熱交換:發生硬體故障時,優先順序較高的 GKE JobSet 工作負載可快速接管備用或優先順序較低的 Cloud TPU 磁碟區。

事前準備

請完成下列前置作業:

如果您使用彈性訓練,請在工作負載容器映像檔中安裝下列套件:

  • pathwaysutils
  • Orbax (orbax-checkpoint):>= 0.12.6 (使用 ocp.v1.training.pathways.Snapshotter 建立記憶體內快照時必須提供)
  • Grain (grain):如果使用 grain.experimental.ElasticIterator,則為必要

如果使用多層檢查點,也請完成下列必要條件:

  • 按照「在 GKE 上使用多層檢查點訓練大規模機器學習模型」一文的說明,設定 GKE 叢集的多層檢查點:
    • 在叢集上啟用多層檢查點 (HighScaleCheckpointing) 和 Cloud Storage FUSE (GcsFuseCsiDriver) 外掛程式,以及 Workload Identity Federation for GKE。
    • 建立已啟用階層命名空間的 Cloud Storage bucket。
    • 將 bucket 的 Storage 物件使用者 (roles/storage.objectUser) Identity and Access Management (IAM) 角色,授予 GKE 多層級檢查點 Kubernetes 服務帳戶 (gke-managed-checkpointing 中的 gke-checkpointing-multitier-node)。
    • 部署 CheckpointConfiguration 自訂資源,指定 Cloud Storage bucket、Cloud TPU 節點選取器和記憶體內磁碟區大小 (inMemoryVolumeSize)。
  • 按照「使用 Pathways 執行共置 Python」一文的說明,建構並推送 Python 3.12 共置 Python 邊車容器映像檔,例如根據 sample_sidecar.dockerfile 中的 pathways-utils。如果 requirements.txt 檔案或 Dockerfile 從 Git 網址安裝套件,請先使用 apt-get 安裝 git,因為精簡基本映像檔會省略 git。在工作負載和 sidecar 映像檔中,使用 Python 3.12 和相符的 jax 和 jaxlib 版本,並符合下列最低版本要求:
    • Orbax (orbax-checkpoint):>= 0.12.4
    • JAX (jax 和 jaxlib):>= 0.10.1

暫停/繼續

GKE 通常會在先占加速器 Pod 之前,向該 Pod 傳送先占通知。Pathways 預設會對所有 Cloud Deploy 部署作業啟用先占容許功能,而 Pathways 加速器工作會監聽這些通知。

收到先占通知時,Pathways 會先判斷是否能儲存及還原工作負載。如果可以,Pathways 會嘗試將機器學習工作負載的目前狀態寫入永久儲存空間 (例如 Cloud Storage),以便在 GKE 淘汰加速器工作前,暫停機器學習工作負載。GKE 稍後重新排定工作時,Pathways 會讀回其永久狀態,恢復機器學習工作負載。

如果無法還原工作負載,Pathways 會關閉受影響的加速器工作,並在單一控制器用戶端程序中引發 jax.errors.JaxRuntimeError (如果已設定彈性訓練)。如果未設定彈性訓練,GKE 會根據 JobSet 重新啟動政策,重新啟動整個工作負載。

使用 JAX 定義的一般機器學習工作負載,會依賴無狀態 Pathways XLA 元件,這些元件可透過高頻寬記憶體 (HBM) 快照還原。某些機器學習工作負載 (例如使用 JAX 共置 Python API 定義的工作負載) 依賴有狀態的 Pathways 元件,因此無法還原。

彈性訓練

彈性訓練可讓訓練工作在硬體故障或切片先占時繼續執行,不必重新啟動整個工作負載。在多配量訓練工作中,當個別配量無法使用時,Pathways 會保留單一控制器用戶端程序和狀況良好的 Cloud TPU 配量。

彈性訓練結合 Pathways 系統功能與訓練程式碼中的復原邏輯:

  • 故障偵測:當 Cloud TPU 切片發生硬體故障或先占時,Pathways 會取消指派受影響的切片,並在工作負載下次存取該切片上的資料時,引發 jax.errors.JaxRuntimeError。由於用戶端程序仍處於啟用狀態,您的程式碼可以擷取這項錯誤、重新設定資源,並繼續訓練。
  • 復原模式:pathwaysutils.elastic.manager.Manager 類別及其 elastic_retry 裝飾器支援兩種復原策略:
    • 暫停和繼續:如果將 minimum_slice_count 設為 None 或總切片數量,訓練會在切片失敗時暫停,並在所有切片恢復正常後繼續。由於切片數量不會因嘗試次數而改變,工作負載可以重複使用現有的裝置網格和編譯的可執行檔。
    • 副本大小調整:如果將 minimum_slice_count 設為小於總 slice 數量,當 slice 失敗時,訓練會在剩餘的使用中 slice 繼續進行。工作負載會重建裝置網格,並針對較小的拓撲重新編譯。背景監控執行緒會定期檢查不活動的切片,並在 elastic_manager.available_inactive_slices 中記錄新恢復健康的切片。接著,訓練迴圈可以使用替換切片重建裝置網格、重新初始化擴充的拓撲,並將目前狀態置於新網格上。
  • 狀態復原:如要在彈性事件後繼續訓練,工作負載會使用記憶體內快照,還原模型參數、最佳化工具狀態和資料疊代器狀態。orbax.checkpoint 中的 ocp.v1.training.pathways.Snapshotter 會以非同步方式,將複製的狀態從 Cloud TPU HBM 複製到每個切片的 pinned_host CPU 記憶體。在復原期間,Snapshotter 會從存留的主機副本重建狀態,並直接重新分 shard 至運作中的 Cloud TPU 網格,不需從遠端儲存空間讀取。

啟用 Pathways Proxy 伺服器的彈性

如要在 GKE 的 Pathways 啟用彈性裝置組合,請在 JobSet 資訊清單的 pathways-proxy 容器 args 欄位中新增 --num_elastic_instances 旗標,並指定工作負載中的彈性 Cloud TPU 磁碟區數量:

- 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

更改下列內容:

  • JAX_VERSION:與 Pathways 伺服器和工作負載映像檔相符的 JAX 版本標記 (例如 0.12.0.1)。
  • BUCKET_NAME:用於 Pathways 暫存檔案的 Cloud Storage bucket。
  • NUM_SLICES:工作負載中的 Cloud TPU 切片數量。

篩選使用中的裝置並建立裝置網格

在 Pathways 工作負載中,jax.devices() 會傳回啟動時所有裝置的靜態清單,且不會在配量失敗或復原時更新。使用彈性訓練時,請使用 elastic_manager.active_devices,確保裝置網格和批次大小只使用健康、活躍的切片:

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"))

在副本大小調整模式中,如果使用中的切片數量有所變更,請使用彈性資料載入器,例如 grain.experimental.ElasticIterator。標準的每主機資料疊代器會儲存每主機的狀態,且無法還原至不同數量的主機。相較之下,ElasticIterator 會追蹤單一全域資料集位置,您可以在任意數量的有效切片中還原該位置。

彈性訓練迴圈

彈性訓練迴圈會結合 manager.Manager、elastic_retry 和 Orbax 的記憶體內 Snapshotter,協調配量監控、故障復原和記憶體內快照,如以下範例所示:

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

設定彈性管理工具和重試行為

每個程序會例項化 manager.Manager(devices=None) 一次。如果省略 devices,管理工具會使用 jax.devices(),並依 slice_index 屬性將裝置分組。

Manager 執行個體會公開下列屬性,以便在訓練期間檢查叢集拓撲:

  • slice_to_devices:從每個 slice_index 到屬於該切片的 jax.Device 物件序列的對應。
  • all_slice_indices:分配中所有切片索引的 frozenset。
  • active_slice_indices:參與有效運算網格的切片索引 frozenset。
  • active_devices:屬於有效切片的一系列 jax.Device 物件,依 slice_index 排序。
  • inactive_slice_indices:分配中未參與運算網格的切片索引 frozenset。
  • available_inactive_slices:背景監控執行緒偵測到健康狀態良好且可重新加入的非使用中切片索引 frozenset。
  • total_slice_count 和 active_slice_count:已分配的切片總數和有效切片數量。
  • default_device:來自有效切片的裝置 0,elastic_retry 會自動設為每次嘗試的預設 JAX 裝置。

您可以將下列引數傳遞至 @elastic_manager.elastic_retry,自訂重試和調度資源行為:

  • minimum_slice_count:開始初始執行或重試前,所需健康配量的最低數量。如果設為 None (預設),elastic_retry 會等待分配中的所有切片 (total_slice_count),並在暫停和繼續模式下運作。如果設為較小的整數 (例如 1),elastic_retry 會以副本大小調整模式運作。
  • poll_interval:訓練期間,彈性訓練管理工具 (Manager) 執行 slice 健康狀態檢查的時間間隔 (以秒為單位)。預設值為 10。
  • timeout:等待 minimum_slice_count 切片變為有效狀態的最長秒數,超過這個時間就會引發 TimeoutError。預設值為 None (無逾時)。
  • pre_callback:選用回呼,在管理員更新 active_slice_indices 後,以及包裝的訓練迴圈函式執行前,在每次嘗試開始時執行。
  • on_elastic_event_callback:選用回呼,在 elastic_retry 擷取到切片 jax.errors.JaxRuntimeError 後,以及下次重試前執行。您可以使用這個回呼清除不完整的檢查點,或重設資料疊代器。
  • retry_policy:可呼叫的 (attempt: int, error: Exception) -> bool,用於判斷是否要在彈性事件後繼續重試。使用 manager.ElasticRetryLimit(max_attempts) 限制嘗試總次數。如果省略,elastic_retry 會無限期重試。

請將 @elastic_manager.elastic_retry 套用至訓練迴圈函式,而非個別訓練步驟。如果只裝飾一個步驟,系統會重新啟動每個步驟的 Slice 健康狀態檢查和背景監控,這會增加負擔,並導致管理工具無法偵測重新加入的 Slice。

發生彈性事件時,JAX 會在堆疊框架展開後,從失敗的嘗試中釋放裝置緩衝區,且沒有變數參照這些陣列。請避免在全域變數或長期回呼中保留失敗嘗試的裝置陣列參照,以便在下次嘗試開始前釋出記憶體。

使用 Orbax 建立記憶體內快照

ocp.v1.training.pathways.Snapshotter 類別 (適用於 orbax-checkpoint 0.12.6 以上版本) 會在 pinned_host 記憶體中,跨切片維護訓練狀態的記憶體內備份:

  • Snapshotter(*, replica_axis_index=0):初始化快照工具,並指定代表資料平行切片副本的網格軸。儲存狀態中的所有 JAX 陣列都必須沿著這個網格軸複製,這樣當某個 slice 失敗時,其餘 slice 仍能保留模型和最佳化器狀態的完整副本。如果狀態包含單一裝置陣列,請先在網格中複製這些陣列,再呼叫 save。
  • save(step, state):以非同步方式將 state 轉移至 pinned_host 記憶體,並沿著 replica_axis_index 將其分割為每個副本樹。如果先前的快照移轉作業仍在進行中,save 會略過新要求,以免訓練迴圈停滯。
  • load(abstract_state, *, reset_snapshot_state=True):探測已儲存的主機副本,找出存活的切片、串連健康狀態良好的副本,並將狀態重新分 shard 至 abstract_state 指定的目標 shard。
  • join():封鎖,直到任何排入佇列的快照作業完成。
  • latest:傳回最近完成的快照中繼資料 (包括 step),如果沒有完成的快照,則傳回 None。

減少切片失敗時的 sharding

如果 Cloud TPU slice 在執行期間失敗或遭到先占,Pathways 會引發 jax.errors.JaxRuntimeError (例如 DATA_LOSS、DEADLINE_EXCEEDED、NOT_FOUND 或 INTERNAL)。在以 @elastic_manager.elastic_retry 裝飾的函式中,elastic_retry 會擷取這個例外狀況並檢查 elastic.is_error_due_to_slice_down(error):

  • 如果錯誤不是由縮減事件引起,elastic_retry 會立即重新引發例外狀況。
  • 如果錯誤是由切片縮減事件引起,elastic_retry 會停止任何執行中的 JAX 分析器追蹤記錄、執行 on_elastic_event_callback,並評估 retry_policy(attempt, error)。
  • 在開始下一次嘗試之前,elastic_retry 會呼叫 elastic.wait_for_slices 一次,輪詢切片健康狀態,直到至少有 minimum_slice_count 個切片處於活動狀態。接著,系統會更新 elastic_manager.active_slice_indices,並在留存的切片上執行訓練迴圈函式。

在切片重新加入時增加 sharding

在副本調整大小模式下,如果工作負載在較少的 slice 上執行,背景監控執行緒會定期對 elastic_manager.inactive_slice_indices 執行健康狀態檢查。當修復或重新排程的切片通過健康狀態檢查時,監控執行緒會將其切片索引新增至 elastic_manager.available_inactive_slices。

如果 elastic_manager.available_inactive_slices 在訓練步驟結束時並非空白,訓練迴圈可以就地擴充,不會遺失訓練進度:

  • 更新有效切片:將 elastic_manager.available_inactive_slices 中的切片索引新增至 elastic_manager.active_slice_indices。更新 active_slice_indices 會導致 elastic_manager 將重新加入的切片納入 elastic_manager.active_devices,並從 available_inactive_slices 中清除。
  • 重建網格和訓練迴圈:從 elastic_manager.active_devices 重建裝置網格,並重新初始化擴充拓撲的訓練步驟和資料疊代器。
  • 重新分割訓練狀態:呼叫 jax.device_put,將目前的訓練狀態放入新的網格分區,不從快照還原。

多層查核點

大規模訓練工作經常中斷,直接在 Cloud Storage 寫入或還原檢查點,可能會造成訓練進度瓶頸。多層級查核點機制會協調 GKE 上的三個儲存層,減少查核點作業負擔和復原時間:

  • 本機 RAM 磁碟:Cloud TPU 工作站會將高頻率查核點寫入掛接在每個 worker 節點上的記憶體內 CSI 磁碟區 (multitier-checkpoint.csi.storage.gke.io)。在同一節點上重新啟動 Pod 時,這個磁碟區會保留。
  • 叢集內對等互連複製:GKE 複製器服務會在叢集內對等互連 Cloud TPU worker 之間複製本機檢查點 shard。
  • Cloud Storage 備份:複製器服務會以非同步方式,將本機檢查點備份至已啟用階層命名空間的 Cloud Storage bucket,不會阻斷 Cloud TPU 訓練步驟。

與多控制器 JAX 不同,每個 Cloud TPU 主機都會執行自己的訓練指令碼,而 Pathways 會在 pathways-head Pod 上執行單一控制器,並將工作調度至 pathways-worker Pod。為了直接在每個 Cloud TPU 主機的本機 RAM 磁碟上讀取及寫入檢查點 shard,而不透過控制器轉送檢查點資料,Pathways 會使用共置 Python。每個 worker Pod 都會與 pathways-worker 一起執行 colocated-python-sidecar 容器,且兩個容器都會掛接多層級檢查點 CSI 磁碟區和共用記憶體目錄 (/tmp/sidecar)。在初始化和訓練期間,Orbax 會將檢查點設定、儲存和還原作業,從 Pathways 控制器調度至每個 Cloud TPU 主機上的 worker sidecar。Pathways 的多層檢查點功能也支援彈性訓練,可縮減或擴充使用中的 Cloud TPU slice。

Pathways 支援搭配 MaxText 使用多層檢查點。如需設定和配置操作說明,請參閱 MaxText 多層檢查點指南。

設定 Pathways 工作負載

您可以使用 Cluster Toolkit (gcluster job submit) 或設定自訂 Pathways JobSet 資訊清單,為 Pathways 工作負載設定多層檢查點。

使用 Cluster Toolkit

使用 gcluster job submit --pathways 提交工作時,請傳遞相符的 cloud-pathways 映像檔標記,以及 --gke-mtc-enabled、--gke-mtc-ramdisk-dir 和 --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" \
    ...

更改下列內容:

  • BUCKET_NAME:用於 Pathways 暫存檔案的 Cloud Storage bucket。
  • JAX_VERSION:與工作負載和 sidecar 映像檔相符的 JAX 版本標記 (例如 0.12.0.1)。
  • SIDECAR_IMAGE:共置 Python 邊車容器映像檔的 URI。

設定這些旗標時,gcluster 會自動設定下列項目:

  • 將 --sidecar_name=external 傳遞至 pathways-proxy 容器。
  • 在每個 worker Pod 中執行 colocated-python-sidecar 容器,並在 pathways-worker 和 colocated-python-sidecar 上掛接共用的 /tmp/sidecar 目錄 (--cloud_pathways_sidecar_shm_directory=/tmp/sidecar)。
  • 在 worker Pod 的 pathways-worker 和 colocated-python-sidecar 中,將 multitier-checkpoint.csi.storage.gke.io CSI 磁碟區掛接至 --gke-mtc-ramdisk-dir 指定的路徑,但不會在 pathways-head Pod 上掛接。

使用自訂 Pathways JobSet 資訊清單

如果您自行管理 Pathways JobSet 資訊清單,而非使用 gcluster,請將 --sidecar_name=external 傳遞至 pathways-proxy。在 worker Pod 規格中,使用 restartPolicy: Always 在 initContainers 下執行 colocated-python-sidecar,並將 shared-memory 磁碟區和 multitier-checkpoint.csi.storage.gke.io CSI 磁碟區掛接在 pathways-worker 和 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

將 SIDECAR_IMAGE 替換為共置 Python 邊車容器映像檔的 URI。

如要查看完整的 Sidecar 設定詳細資料 (包括 PathwaysJobSet 產生和選用的 Unix 網域 Socket 覆寫),請參閱「使用 Sidecar 部署 Pathways JobSet」。如要在部署後查看 sidecar 啟動和共用記憶體記錄,請參閱「驗證 sidecar 部署作業」。

在自訂 JAX 工作負載中使用 Orbax 多層檢查點

在 Pathways 上執行的自訂 JAX 訓練指令碼中,使用 orbax.checkpoint.experimental.emergency.multi_tier_checkpointing 套件,並在 initialize_multi_tier_checkpointing 和 ReplicatorCheckpointManagerOptions 中設定 use_colocated_python=True:

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()

熱插拔

熱交換是 GKE JobSet API 的一項功能,可讓優先順序較高的工作快速接管優先順序較低工作的資源,盡可能縮短停機時間並加快復原速度。

建立 JobSet 時,GKE 會按照 JobSet 設定,將工作負載排程至多個 slice。如果一或多個切片發生硬體故障,GKE 會將受影響的 Pod 標示為失敗。如果 GKE 叢集有備用 slice 執行優先順序較低的工作,JobSet 控制器會將故障 slice 的工作負載,從優先順序較高的工作重新對應至該備用 slice。這項重新對應作業通常會在 1 分鐘內完成。

JobSet 重新啟動時,下列情況可能會發生熱交換:

  • 預設模式:如果同一個叢集內有閒置的備用 Cloud TPU slice,Kubernetes 排程器會優先將重新啟動的工作排定至這些 slice,而不是等待故障的 slice 修復。這種排程行為可加快復原速度。
  • 異質工作負載:在執行多個工作負載且已設定 Kubernetes PriorityClass 資源的叢集中,重新啟動 JobSet 可能會觸發熱插拔。如果重新啟動的工作親和性與優先順序較低的工作資源相符,Kubernetes 會優先處理優先順序較低的工作,讓優先順序較高的工作可以啟動,不必等待切片修復。例如,您可以使用 PriorityClass 資源,為 Pathways worker Pod 設定不同的優先順序。

如要在叢集中使用優先順序,請定義 PriorityClass 資訊清單,並儲存為 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."

將這個 YAML 套用至 GKE 叢集,並確認優先順序類別是否存在:

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

接著,將新的優先順序類別附加至 Pathways 工作負載。如果您使用 Cluster Toolkit 提交工作負載,請將 --priority=high-prior-job 傳遞至 gcluster job submit 指令,這會在 pathways-head 和 worker Pod 上設定 priorityClassName。如果您自行編寫 JobSet 資訊清單,請在執行 pathways-worker 容器的 worker 複製工作 Pod 範本中設定 priorityClassName:

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

如果您使用已啟用 Pathways 的 Cluster Toolkit Cloud TPU 藍圖建立叢集,叢集就會包含 very-low、low、medium、high 和 very-high 優先順序類別。您可以將其中一個類別傳遞至 --priority,而不必自行建立。

清除所用資源

為避免持續產生費用,或在叢集留下未使用的排程資源,請刪除您在本指南中建立的資源:

  1. 刪除 Pathways JobSet:

    kubectl delete jobset JOBSET_NAME
    

    將 JOBSET_NAME 替換為 JobSet 的 metadata.name 值。

  2. 選用:刪除您建立的自訂 PriorityClass:

    kubectl delete priorityclass high-prior-job
    
  3. 選用:如果叢集上沒有其他工作負載使用多層檢查點,請刪除 CheckpointConfiguration 自訂資源 (刪除後,多層檢查點 CSI 驅動程式會從節點解除安裝):

    kubectl delete checkpointconfiguration CHECKPOINT_CONFIG_NAME
    

    將 CHECKPOINT_CONFIG_NAME 替換為 CheckpointConfiguration 資源的 metadata.name 值。

後續步驟