本頁面說明機器學習工程師如何為 Google Kubernetes Engine (GKE) 上的 Pathways 工作負載設定韌性功能,讓大規模訓練工作能從預定中斷和非預期的硬體故障中復原。
Pathways 透過下列方式提供復原力優勢:
- 暫停與恢復:讓工作負載容許預定的中斷,例如先占通知,而不需要自訂先占處理程式碼。
- 彈性訓練:在訓練程式碼中使用復原邏輯,讓工作負載容許非預期的硬體故障,而不會導致用戶端當機。
- 多層級查核點:工作負載可使用共置 Python,在 Cloud TPU 工作站之間儲存高頻率的本機和對等複製查核點,並透過非同步 Cloud Storage 備份縮短復原時間。
- 熱交換:發生硬體故障時,優先順序較高的 GKE
JobSet工作負載可快速接管備用或優先順序較低的 Cloud TPU 磁碟區。
事前準備
請完成下列前置作業:
- 設定 Cluster Toolkit。
- 安裝 Kubernetes 工具。
- 安裝 Google Cloud CLI。
- 啟用 Kubernetes Engine API。
- 使用 Pathways 建立 GKE 叢集。
- 建立 Cloud Storage bucket,用於存放 Pathways 暫存檔案。
如果您使用彈性訓練,請在工作負載容器映像檔中安裝下列套件:
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
- Orbax (
暫停/繼續
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_hostCPU 記憶體。在復原期間,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容器。 - 在每個
workerPod 中執行colocated-python-sidecar容器,並在pathways-worker和colocated-python-sidecar上掛接共用的/tmp/sidecar目錄 (--cloud_pathways_sidecar_shm_directory=/tmp/sidecar)。 - 在
workerPod 的pathways-worker和colocated-python-sidecar中,將multitier-checkpoint.csi.storage.gke.ioCSI 磁碟區掛接至--gke-mtc-ramdisk-dir指定的路徑,但不會在pathways-headPod 上掛接。
使用自訂 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,而不必自行建立。
清除所用資源
為避免持續產生費用,或在叢集留下未使用的排程資源,請刪除您在本指南中建立的資源:
刪除 Pathways
JobSet:kubectl delete jobset JOBSET_NAME將
JOBSET_NAME替換為JobSet的metadata.name值。選用:刪除您建立的自訂
PriorityClass:kubectl delete priorityclass high-prior-job選用:如果叢集上沒有其他工作負載使用多層檢查點,請刪除
CheckpointConfiguration自訂資源 (刪除後,多層檢查點 CSI 驅動程式會從節點解除安裝):kubectl delete checkpointconfiguration CHECKPOINT_CONFIG_NAME將
CHECKPOINT_CONFIG_NAME替換為CheckpointConfiguration資源的metadata.name值。