翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# HyperPod チェックポイントレストレーニング機能
チェックポイントレストレーニングのトレーニング機能については、以下のページを参照してください。
**Topics**
+ [Amazon SageMaker HyperPod チェックポイントレストレーニングリポジトリ](#sagemaker-eks-checkpointless-repositories)
+ [コレクティブコミュニケーションの初期化の改善](sagemaker-eks-checkpointless-features-communication.md)
+ [メモリマッピングされたデータローダー](sagemaker-eks-checkpointless-features-mmap.md)
+ [処理中の復旧とチェックポイントレストレーニング](sagemaker-eks-checkpointless-in-process-recovery.md)
## Amazon SageMaker HyperPod チェックポイントレストレーニングリポジトリ
[ HyperPod チェックポイントレストレーニング](https://github.com/aws/sagemaker-hyperpod-checkpointless-training#)は、フレームワークレベルの最適化を通じて、大規模な分散トレーニング環境でのクラスター障害からの復旧を加速します。これらの最適化は、強化された NCCL 初期化の改善、データロードの最適化、処理中およびチェックポイントレスリカバリコンポーネントを含むベースコンテナイメージを介して提供されます。HyperPod チェックポイントレストレーニングパッケージは、この基盤上に構築されています。
チェックポイントレストレーニングは、協調して実行される 3 つの最適化トラックを介して有効になります。
+ **コミュニケーションの初期化の改善 (NCCL と Gloo)** - ランクピアとリングの情報を分散することでコミュニケーションのボトルネックを排除します (下の赤いボックス）。
+ **データロードの最適化** - 再起動オペレーション中にデータの最初のバッチを処理するために必要な時間を短縮します (以下のオレンジ色のボックス）。
+ **プログラム再起動のオーバーヘッド削減** - 再起動コストを最小限に抑え、正常なノードのプロセス復旧を通じてチェックポイントレス補充を有効にします (下の青と緑のボックス）。
![\[alt text not found\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimization-tracks.png)
# コレクティブコミュニケーションの初期化の改善
NCCL と Gloo は、分散トレーニングプロセス全体で集合オペレーション (全削減やブロードキャストなど) を可能にする基本的な通信ライブラリです。ただし、従来の NCCL と Gloo の初期化では、障害復旧中にボトルネックが発生する可能性があります。
標準復旧プロセスでは、すべてのプロセスが一元化された TCPStore に接続し、ルートプロセスを通じて調整する必要があるため、再起動時に特に問題となるコストのかかるオーバーヘッドが発生します。この一元化された設計では、必須の TCPStore 接続の調整オーバーヘッド、再起動ごとに完全な初期化シーケンスを繰り返す必要がある復旧遅延、ルートプロセス自体の単一障害点という 3 つの重要な問題が発生します。これにより、トレーニングが初期化または再開されるたびに、コストが高く一元化された調整ステップが課されます。
HyperPod チェックポイントレストレーニングは、これらの調整のボトルネックを排除し、初期化を「ルートレス」およびTCPStoreless."
## ルートレス設定
ルートレスを有効にするには、次の環境変数を公開します。
```
export HPCT_USE_ROOTLESS=1 && \
sysctl -w net.ipv4.ip_local_port_range="20000 65535" && \
```
HPCT\$1USE\$1ROOTLESS: 0 または 1。を使用してルートレスを有効または無効にする
sysctl -w net.ipv4.ip\$1local\$1port\$1range"20000 65535": システムポート範囲を設定する
ルートレスを有効にする[例を参照してください](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml#L111-L113)。
## ルートレス
HyperPod チェックポイントレストレーニングは、NCCL および Gloo プロセスグループ用の新しい初期化方法であるルートレスおよび TCPStoreless を提供します。
これらの最適化の実装には、NCCL、Gloo、PyTorch の変更が含まれます。
+ 下位互換性を維持しながら、サードパーティーのライブラリ APIs を拡張して、ルートレスおよびストアレスの NCCL と Gloo 最適化を有効にする
+ プロセスグループのバックエンドを更新して、条件付きで最適化されたパスを使用し、プロセス内の復旧の問題を処理する
+ グローバルグループカウンターを通じて対称アドレスパターンを維持しながら、PyTorch 分散レイヤーでの高価な TCPStore 作成をバイパスする
次のグラフは、分散トレーニングライブラリのアーキテクチャと、チェックポイントレストレーニングで行われた変更を示しています。
![\[次のグラフは、分散トレーニングライブラリのアーキテクチャと、チェックポイントレストレーニングで行われた変更を示しています。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-libraries.png)
### NCCL と Gloo
これらは、集合通信のコア機能を実行する独立したパッケージです。ncclCommInitRank などの主要な APIs を提供し、通信ネットワークを初期化し、基盤となるリソースを管理し、集合通信を実行します。NCCL と Gloo でカスタム変更を行った後、ルートレスとストアレスは通信ネットワークの初期化を最適化します (TCPStore への接続をスキップするなど）。元のコードパスを使用するか、最適化されたコードパスを柔軟に切り替えることができます。
### PyTorch プロセスグループのバックエンド
プロセスグループのバックエンド、特に ProcessGroupNCCL と ProcessGroupGloo は、対応する基盤となるライブラリの APIs を呼び出して ProcessGroup APIsを実装します。サードパーティーライブラリの APIs を拡張するため、それらを適切に呼び出し、お客様の設定に基づいてコードパスを切り替える必要があります。
最適化コードパスに加えて、プロセスグループのバックエンドも変更して、プロセス内の復旧をサポートします。
# メモリマッピングされたデータローダー
もう 1 つの再起動オーバーヘッドはデータのロードに起因します。データローダーが初期化し、リモートファイルシステムからデータをダウンロードしてバッチ処理している間、トレーニングクラスターはアイドル状態のままになります。
これに対処するために、Memory Mapped DataLoader (MMAP) Dataloader を導入しました。この Dataloader は、プリフェッチされたバッチを永続メモリにキャッシュし、障害による再起動後も使用できるようにします。このアプローチにより、データローダーのセットアップ時間がなくなり、キャッシュされたバッチを使用してトレーニングをすぐに再開できます。一方、データローダーは後続のデータをバックグラウンドで同時に再初期化して取得します。データキャッシュは、トレーニングデータを必要とする各ランクに存在し、2 種類のバッチを維持します。トレーニングに使用された最近消費されたバッチと、すぐに使用できるプリフェッチされたバッチです。
![\[この図は、MMAP Dataloader、キャッシュ、消費されたバッチを示しています。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-mmap-dataloader.png)
MMAP データローダーには次の 2 つの機能があります。
+ **データプリフェッチ** - データローダーによって生成されたデータをプロアクティブにフェッチしてキャッシュします
+ **永続的キャッシュ** - プロセスの再起動後も存続する一時的なファイルシステムに、消費されたバッチとプリフェッチされたバッチの両方を保存します。
キャッシュを使用すると、トレーニングジョブは次の利点があります。
+ **メモリフットプリントの削減** - メモリマップ I/O を活用して、ホスト CPU メモリ内のデータの単一の共有コピーを維持し、GPU プロセス間の冗長コピーを排除GPUs (8 GPU を搭載した p5 インスタンスで 8 コピーから 1 コピーに削減するなど）。
+ **Faster Recovery** - キャッシュされたバッチからトレーニングをすぐに再開できるようにすることで、平均再起動時間 (MTTR) を短縮し、データローダーの再初期化と最初のバッチ生成の待機をなくします。
## MMAP 設定
MMAP を使用するには、元のデータモジュールを に渡します。 `MMAPDataModule`
```
data_module=MMAPDataModule(
data_module=MY_DATA_MODULE(...),
mmap_config=CacheResumeMMAPConfig(
cache_dir=self.cfg.mmap.cache_dir,
checkpoint_frequency=self.cfg.mmap.checkpoint_frequency),
)
```
`CacheResumeMMAPConfig`: MMAP Dataloader パラメータは、キャッシュディレクトリの場所、サイズ制限、データフェッチ委任を制御します。デフォルトでは、ノードあたりの TP ランク 0 のみがソースからデータを取得し、同じデータレプリケーショングループ内の他のランクは共有キャッシュから読み取るため、冗長な転送がなくなります。
`MMAPDataModule`: 元のデータモジュールをラップし、トレーニングと検証の両方で mmap データローダーを返します。
MMAP を有効にする[例を参照してください](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune_checkpointless.py#L101-L109)。
## API リファレンス
### CacheResumeMMAPConfig
```
class hyperpod_checkpointless_training.dataloader.config.CacheResumeMMAPConfig(
cache_dir='/dev/shm/pdl_cache',
prefetch_length=10,
val_prefetch_length=10,
lookback_length=2,
checkpoint_frequency=None,
model_parallel_group=None,
enable_batch_encryption=False)
```
HyperPod チェックポイントレストレーニングのキャッシュ再開メモリマップ (MMAP) データローダー機能の設定クラス。
この設定により、キャッシュ機能とプリフェッチ機能による効率的なデータロードが可能になり、キャッシュされたデータバッチをメモリマップファイルに維持することで、障害発生後すぐにトレーニングを再開できます。
**パラメータ**
+ **cache\$1dir** (str、オプション) – キャッシュされたデータバッチを保存するためのディレクトリパス。デフォルト: "/dev/shm/pdl\$1cache"
+ **prefetch\$1length** (int、オプション) – トレーニング中にプリフェッチするバッチの数。デフォルト: 10
+ **val\$1prefetch\$1length** (int、オプション) – 検証中にプリフェッチするバッチの数。デフォルト: 10
+ **lookback\$1length** (int、オプション) – 再利用の可能性のためにキャッシュに保持する以前に使用したバッチの数。デフォルト: 2
+ **checkpoint\$1frequency** (int、オプション) – モデルチェックポイントステップの頻度。キャッシュパフォーマンスの最適化に使用されます。デフォルト: なし
+ **model\$1parallel\$1group** (オブジェクト、オプション) – モデル並列処理のプロセスグループ。None の場合、 は自動的に作成されます。デフォルト: なし
+ **enable\$1batch\$1encryption** (bool、オプション) – キャッシュされたバッチデータの暗号化を有効にするかどうか。デフォルト: False
**方法**
```
create(dataloader_init_callable,
parallel_state_util,
step,
is_data_loading_rank,
create_model_parallel_group_callable,
name='Train',
is_val=False,
cached_len=0)
```
設定された MMAP データローダーインスタンスを作成して返します。
**パラメータ**
+ **dataloader\$1init\$1callable** (呼び出し可能) – 基盤となるデータローダーを初期化する関数
+ **parallel\$1state\$1util** (オブジェクト) – プロセス間で並列状態を管理するためのユーティリティ
+ **step** (int) – トレーニング中に から再開するデータステップ
+ **is\$1data\$1loading\$1rank** (Callable) – 現在のランクがデータをロードする必要がある場合に True を返す関数
+ **create\$1model\$1parallel\$1group\$1callable** (呼び出し可能) – モデル並列プロセスグループを作成する関数
+ **name** (str、オプション) – データローダーの名前識別子。デフォルト: 「トレーニング」
+ **is\$1val** (bool、オプション) – これが検証データローダーであるかどうか。デフォルト: False
+ **cached\$1len** (int、オプション) – 既存のキャッシュから再開する場合のキャッシュデータの長さ。デフォルト: 0
`CacheResumePrefetchedDataLoader` または を返します `CacheResumeReadDataLoader` — 設定された MMAP データローダーインスタンス
ステップパラメータが `ValueError`の場合、 が上がります`None`。
**例**
```
from hyperpod_checkpointless_training.dataloader.config import CacheResumeMMAPConfig
# Create configuration
config = CacheResumeMMAPConfig(
cache_dir="/tmp/training_cache",
prefetch_length=20,
checkpoint_frequency=100,
enable_batch_encryption=False
)
# Create dataloader
dataloader = config.create(
dataloader_init_callable=my_dataloader_init,
parallel_state_util=parallel_util,
step=current_step,
is_data_loading_rank=lambda: rank == 0,
create_model_parallel_group_callable=create_mp_group,
name="TrainingData"
)
```
**Notes** (メモ)
+ キャッシュディレクトリには十分なスペースと高速 I/O パフォーマンス (インメモリストレージの /dev/shm など) が必要です。
+ を設定することで、キャッシュ管理をモデルチェックポイントに合わせることでキャッシュパフォーマンス`checkpoint_frequency`が向上します。
+ 検証データローダー (`is_val=True`) の場合、ステップは 0 にリセットされ、コールドスタートが強制されます。
+ 現在のランクがデータのロードを担当するかどうかに基づいて、さまざまなデータローダー実装が使用されます。
### MMAPDataModule
```
class hyperpod_checkpointless_training.dataloader.mmap_data_module.MMAPDataModule(
data_module,
mmap_config,
parallel_state_util=MegatronParallelStateUtil(),
is_data_loading_rank=None)
```
チェックポイントレストレーニングのためにメモリマップ (MMAP) データロード機能を既存の DataModule に適用する PyTorch Lightning DataModules ラッパー。
このクラスは、既存の PyTorch Lightning DataModule をラップし、MMAP 機能で強化します。これにより、トレーニングの失敗時に効率的なデータキャッシュと高速リカバリが可能になります。チェックポイントレストレーニング機能を追加しながら、元の DataModule インターフェイスとの互換性を維持します。
パラメータ
data\$1module (pl.LightningDataModule)
ラップする基盤となる DataModule (LLMDataModule など)
mmap\$1config (MMAPConfig)
キャッシュ動作とパラメータを定義する MMAP 設定オブジェクト
`parallel_state_util` (MegatronParallelStateUtil、オプション)
分散プロセス全体で並列状態を管理するためのユーティリティ。デフォルト: MegatronParallelStateUtil()
`is_data_loading_rank` (呼び出し可能、オプション)
現在のランクがデータをロードする必要がある場合に True を返す関数。None の場合、デフォルトで parallel\$1state\$1util.is\$1tp\$10 になります。デフォルト: なし
**属性**
`global_step` (int)
チェックポイントからの再開に使用される現在のグローバルトレーニングステップ
`cached_train_dl_len` (int)
トレーニングデータローダーのキャッシュされた長さ
`cached_val_dl_len` (int)
検証データローダーのキャッシュされた長さ
**方法**
```
setup(stage=None)
```
指定されたトレーニングステージの基盤となるデータモジュールをセットアップします。
`stage` (str、オプション)
トレーニングのステージ ('fit'、'validate'、'test'、または 'predict')。デフォルト: なし
```
train_dataloader()
```
MMAP ラッピングを使用してトレーニング DataLoader を作成します。
*戻り値:* DataLoader – キャッシュ機能とプリフェッチ機能を備えた MMAP ラップトレーニング DataLoader
```
val_dataloader()
```
MMAP ラップを使用して検証 DataLoader を作成します。
*戻り値:* DataLoader – キャッシュ機能を備えた MMAP ラップ検証 DataLoader
```
test_dataloader()
```
基盤となるデータモジュールがサポートしている場合は、テスト DataLoader を作成します。
*戻り値:* DataLoader または None – 基盤となるデータモジュールから DataLoader をテストするか、サポートされていない場合は None
```
predict_dataloader()
```
基盤となるデータモジュールがサポートしている場合は、予測 DataLoader を作成します。
*戻り値:* DataLoader または None – 基盤となるデータモジュールから DataLoader を予測するか、サポートされていない場合は None
```
load_checkpoint(checkpoint)
```
チェックポイント情報をロードして、特定のステップからトレーニングを再開します。
チェックポイント (dict)
「global\$1step」キーを含むチェックポイントディクショナリ
```
get_underlying_data_module()
```
基盤となるラップされたデータモジュールを取得します。
*戻り値:* pl.LightningDataModule – ラップされた元のデータモジュール
```
state_dict()
```
チェックポイント用の MMAP DataModule の状態ディクショナリを取得します。
*戻り値:* dict – キャッシュされたデータローダーの長さを含むディクショナリ
```
load_state_dict(state_dict)
```
状態ディクショナリをロードして MMAP DataModule の状態を復元します。
`state_dict` (dict)
ロードする状態ディクショナリ
**プロパティ**
```
data_sampler
```
基盤となるデータモジュールのデータサンプラーを NeMo フレームワークに公開します。
*戻り値:* オブジェクトまたはなし – 基になるデータモジュールのデータサンプラー
**例**
```
from hyperpod_checkpointless_training.dataloader.mmap_data_module import MMAPDataModule
from hyperpod_checkpointless_training.dataloader.config import CacheResumeMMAPConfig
from my_project import MyLLMDataModule
# Create MMAP configuration
mmap_config = CacheResumeMMAPConfig(
cache_dir="/tmp/training_cache",
prefetch_length=20,
checkpoint_frequency=100
)
# Create original data module
original_data_module = MyLLMDataModule(
data_path="/path/to/data",
batch_size=32
)
# Wrap with MMAP capabilities
mmap_data_module = MMAPDataModule(
data_module=original_data_module,
mmap_config=mmap_config
)
# Use in PyTorch Lightning Trainer
trainer = pl.Trainer()
trainer.fit(model, data=mmap_data_module)
# Resume from checkpoint
checkpoint = {"global_step": 1000}
mmap_data_module.load_checkpoint(checkpoint)
```
**Notes** (メモ)
+ ラッパーは、\$1\$1getattr\$1\$1 を使用して、基盤となるデータモジュールへのほとんどの属性アクセスを委任します。
+ データロードランクのみが基盤となるデータモジュールを実際に初期化して使用します。他のランクはフェイクデータローダーを使用します。
+ キャッシュされたデータローダーの長さは、トレーニング再開中のパフォーマンスを最適化するために維持されます
# 処理中の復旧とチェックポイントレストレーニング
HyperPod チェックポイントレストレーニングでは、モデルの冗長性を使用して耐障害性トレーニングを有効にします。コア原則は、モデルとオプティマイザの状態が複数のノードグループに完全にレプリケートされ、重みの更新とオプティマイザの状態の変更が各グループ内で同期的にレプリケートされることです。障害が発生すると、正常なレプリカはオプティマイザのステップを完了し、更新されたモデル/オプティマイザの状態を復旧中のレプリカに送信します。
このモデル冗長性ベースのアプローチにより、いくつかの障害処理メカニズムが可能になります。
+ **処理中の復旧: **障害が発生してもプロセスはアクティブのままで、すべてのモデルとオプティマイザの状態を GPU メモリに最新の値で保持します。
+ **正常な中止処理:** 影響を受けるオペレーションの制御された中止とリソースクリーンアップ
+ **コードブロックの再実行:** 再実行可能なコードブロック (RCB) 内の影響を受けるコードセグメントのみを再実行します。
+ **トレーニングの進行状況が失われないチェックポイントレスリカバリ: **プロセスが保持され、状態がメモリに残るため、トレーニングの進行状況は失われません。障害が発生すると、最後に保存されたチェックポイントから再開するのではなく、前のステップからトレーニングが再開されます。
**チェックポイントレス設定**
チェックポイントレストレーニングのコアスニペットを次に示します。
```
from hyperpod_checkpointless_training.inprocess.train_utils import wait_rank
wait_rank()
def main():
@HPWrapper(
health_check=CudaHealthCheck(),
hp_api_factory=HPAgentK8sAPIFactory(),
abort_timeout=60.0,
checkpoint_manager=PEFTCheckpointManager(enable_offload=True),
abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),
finalize=CheckpointlessFinalizeCleanup(),
)
def run_main(cfg, caller: Optional[HPCallWrapper] = None):
...
trainer = Trainer(
strategy=CheckpointlessMegatronStrategy(...,
num_distributed_optimizer_instances=2),
callbacks=[..., CheckpointlessCallback(...)],
)
trainer.fresume = resume
trainer._checkpoint_connector = CheckpointlessCompatibleConnector(trainer)
trainer.wrapper = caller
```
+ `wait_rank`: すべてのランクは、HyperpodTrainingOperator インフラストラクチャからのランク情報を待機します。
+ `HPWrapper`: 再実行コードブロック (RCB) の再起動機能を有効にする Python 関数ラッパー。デコレータは実行時にモニタリングする RCBs の数を判断できないため、実装では Python デコレータではなくコンテキストマネージャーを使用します。
+ `CudaHealthCheck`: GPU と同期することで、現在のプロセスの CUDA コンテキストが正常な状態であることを確認します。LOCAL\$1RANK 環境変数で指定されたデバイスを使用するか、LOCAL\$1RANK が設定されていない場合は、デフォルトでメインスレッドの CUDA デバイスになります。
+ `HPAgentK8sAPIFactory`: この API により、チェックポイントレストレーニングは Kubernetes トレーニングクラスター内の他のポッドのトレーニングステータスをクエリできます。また、続行する前にすべてのランクが正常に中止および再起動操作を完了するインフラストラクチャレベルの障壁も提供します。
+ `CheckpointManager`: チェックポイントレス耐障害性のためのインメモリチェックポイントとpeer-to-peerリカバリを管理します。これには、次の主要な責任があります。
+ **メモリ内チェックポイント管理**: NeMo モデルチェックポイントをメモリに保存して管理し、チェックポイントレスリカバリシナリオ中にディスク I/O なしで高速リカバリを実現します。
+ **Recovery Feasibility Validation**: グローバルステップの整合性、ランクの正常性、モデル状態の整合性を検証することで、チェックポイントレスリカバリが可能かどうかを判断します。
+ **Peer-to-Peerリカバリオーケストレーション**: 高速リカバリのための分散通信を使用して、正常なランクと失敗したランク間のチェックポイント転送を調整します。
+ **RNG 状態管理**: 決定論的復旧のために、Python、NumPy、PyTorch、Megatron 全体で乱数ジェネレーターの状態を保存および復元します。
+ **[オプション] チェックポイントオフロード**: GPU に十分なメモリ容量がない場合、メモリチェックポイントの CPU へのオフロード。
+ `PEFTCheckpointManager`: PEFT 微調整の基本モデルの重みを維持すること`CheckpointManager`で拡張されます。
+ `CheckpointlessAbortManager`: エラーが発生したときにバックグラウンドスレッドで中止オペレーションを管理します。デフォルトでは、TransformerEngine、Checkpointing、TorchDistributed、DataLoader は中止されます。ユーザーは、必要に応じてカスタム中止ハンドラーを登録できます。中止が完了すると、リソースリークを防ぐために、すべての通信を停止し、すべてのプロセスとスレッドを終了する必要があります。
+ `CheckpointlessFinalizeCleanup`: バックグラウンドスレッドで安全に中止またはクリーンアップできないコンポーネントのメインスレッドで最終的なクリーンアップ操作を処理します。
+ `CheckpointlessMegatronStrategy`: これは、Nemo の `MegatronStrategy` から継承されます。チェックポイントレストレーニングでは`num_distributed_optimizer_instances`、オプティマイザレプリケーションが行われるように 2 以上が必要です。この戦略では、ルートレスなど、重要な属性登録とプロセスグループの初期化も処理されます。
+ `CheckpointlessCallback`: NeMo トレーニングをチェックポイントレストレーニングの耐障害性システムと統合する Lightning コールバック。これには、次の主要な責任があります。
+ **トレーニングステップライフサイクル管理**: トレーニングの進行状況を追跡し、ParameterUpdateLock と調整して、トレーニング状態 (最初のステップとその後のステップ) に基づいてチェックポイントレスリカバリを有効または無効にします。
+ **Checkpoint State Coordination**: インメモリ PEFT ベースモデルチェックポイントの保存/復元を管理します。
+ `CheckpointlessCompatibleConnector`: チェックポイントファイルをメモリに事前ロード`CheckpointConnector`しようとする PTL。ソースパスはこの優先度で決定されます。
+ チェックポイントレスリカバリを試す
+ チェックポイントレスが None を返す場合は、parent.resume\$1start() にフォールバックします。
コードにチェックポイントレストレーニング機能を追加するには[、例](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune.py)を参照してください。
**概念**
このセクションでは、チェックポイントレストレーニングの概念について説明します。Amazon SageMaker HyperPod でのチェックポイントレストレーニングは、処理中の復旧をサポートします。この API インターフェイスは、NVRx APIsと同様の形式に従います。
**概念 - 再実行可能なコードブロック (RCB)**
障害が発生すると、正常なプロセスは存続しますが、トレーニング状態と Python スタックを回復するには、コードの一部を再実行する必要があります。再実行コードブロック (RCB) は、障害復旧中に再実行される特定のコードセグメントです。次の例では、RCB はトレーニングスクリプト全体 (main() の下のすべて) を包含しています。つまり、各障害復旧はインメモリモデルとオプティマイザの状態を維持しながらトレーニングスクリプトを再起動します。
**概念 - 障害コントロール**
チェックポイントレストレーニング中に障害が発生した場合、障害コントローラーモジュールは通知を受け取ります。この障害コントローラーには、次のコンポーネントが含まれています。
+ **障害検出モジュール:** インフラストラクチャの障害通知を受信します
+ **RCB 定義 APIs:** ユーザーがコード内の再実行可能コードブロック (RCB) を定義できるようにします
+ **モジュールを再起動する:** RCB を終了し、リソースをクリーンアップして、RCB を再起動します
![\[この図は、チェックポイントレストレーニング中に障害が発生した場合に障害コントローラーモジュールが通知を受け取る方法を示しています。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-fault-controller-module.png)
**概念 - モデルの冗長性**
通常、大規模なモデルトレーニングには、モデルを効率的にトレーニングするための十分なデータ並列サイズが必要です。PyTorch DDP や Horovod などの従来のデータ並列処理では、モデルは完全にレプリケートされます。DeepSpeed ZeRO オプティマイザや FSDP などのより高度なシャーディングデータ並列処理手法は、ハイブリッドシャーディングモードもサポートしています。これにより、シャーディンググループ内のモデル/オプティマイザの状態をシャーディングし、レプリケーショングループ間で完全にレプリケートできます。NeMo には、冗長性を可能にする引数 num\$1distributed\$1optimizer\$1instances によるこのハイブリッドシャーディング機能もあります。
ただし、冗長性を追加すると、モデルがクラスター全体で完全にシャーディングされないため、デバイスのメモリ使用量が増えます。冗長メモリの量は、ユーザーが実装した特定のモデルシャーディング手法によって異なります。低精度モデルの重み、勾配、およびアクティベーションメモリは、モデル並列処理によってシャーディングされるため、影響を受けません。高精度のマスターモデルの重み/勾配とオプティマイザの状態に影響します。冗長モデルレプリカを 1 つ追加すると、デバイスのメモリ使用量が 1 つの DCP チェックポイントサイズとほぼ同等に増加します。
ハイブリッドシャーディングは、DP グループ全体の集合体を比較的小さな集合体に分割します。以前は、DP グループ全体に縮小散布と全集計がありました。ハイブリッドシャーディングの後、削減散布は各モデルレプリカ内でのみ実行され、モデルレプリカグループ全体ですべて削減されます。全集合は、各モデルレプリカ内でも実行されます。その結果、通信ボリューム全体はほぼ変更されませんが、集合体はより小さなグループで実行されているため、レイテンシーは向上することが予想されます。
**概念 - 失敗と再起動のタイプ**
次の表は、さまざまな障害タイプと関連する復旧メカニズムを示しています。チェックポイントレストレーニングは、最初に処理中の復旧を介して障害復旧を試み、その後にプロセスレベルの再起動を試みます。致命的な障害が発生した場合 (複数のノードが同時に失敗した場合など) にのみ、ジョブレベルの再起動にフォールバックします。
| 失敗タイプ | 原因 | 復旧タイプ | 復旧メカニズム |
| --- | --- | --- | --- |
| 処理中の障害 | コードレベルのエラー、例外 | プロセス内リカバリ (IPR) | 既存のプロセス内で RCB を再実行します。正常なプロセスはアクティブのままです |
| プロセス再起動の失敗 | CUDA コンテキストの破損、プロセスの終了 | プロセスレベルの再起動 (PLR) | SageMaker HyperPod トレーニングオペレーターがプロセスを再起動し、K8s ポッドの再起動をスキップする |
| ノード置換の失敗 | 永続的ノード/GPU ハードウェア障害 | ジョブレベルの再起動 (JLR) | 失敗したノードを置き換え、トレーニングジョブ全体を再起動する |
**概念 - オプティマイザステップのアトミックロック保護**
モデルの実行は、フォワードプロパゲーション、バックワードプロパゲーション、オプティマイザの 3 つのフェーズに分かれています。復旧動作は、障害のタイミングによって異なります。
+ **フォワード/バックワード伝達:** 現在のトレーニングステップの先頭にロールバックし、モデルの状態を代替ノード (複数可) にブロードキャストします。
+ **オプティマイザステップ:** 正常なレプリカがロック保護の下でステップを完了し、更新されたモデルの状態を代替ノード (複数可) にブロードキャストできるようにします。
この戦略により、完了したオプティマイザの更新が破棄されることがなくなり、障害復旧時間を短縮できます。
![\[この図は、障害が発生する前か後かに応じて、障害がどのように処理されるかを示しています。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimizer.png)
## チェックポイントレストレーニングのフロー図
![\[この図は、チェックポイントレストレーニングフローを示しています。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-flow.png)
次の手順では、障害検出とチェックポイントレスリカバリプロセスの概要を示します。
1. トレーニングループの開始
1. 障害が発生する
1. チェックポイントレス再開の実現可能性を評価する
1. チェックポイントレス再開が可能かどうかを確認する
+ 可能であれば、チェックポイントレス再利用を試みる
+ 再開が失敗した場合、ストレージからのチェックポイントロードにフォールバックする
+ 再開が成功した場合、トレーニングは復旧状態から続行されます
+ 実行可能でない場合は、ストレージからのチェックポイントロードにフォールバックする
1. リソースのクリーンアップ - 再起動に備えて、すべてのプロセスグループとバックエンドを中止し、リソースを解放します。
1. トレーニングループを再開する - 新しいトレーニングループが開始され、プロセスはステップ 1 に戻ります。
## API リファレンス
### wait\$1rank
```
hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()
```
HyperPod からランク情報を待機して取得し、分散トレーニング変数を使用して現在のプロセス環境を更新します。
この関数は、分散トレーニング用の正しいランク割り当てと環境変数を取得します。これにより、各プロセスが分散トレーニングジョブのロールに適した設定を取得します。
**パラメータ**
なし
**戻り値**
**[なし]**
**Behavior**
+ **プロセスチェック**: サブプロセスから呼び出された場合に実行をスキップします ( MainProcess でのみ実行されます)
+ **環境の取得**: 環境変数`WORLD_SIZE`から現在の `RANK`と を取得します。
+ **HyperPod 通信**: HyperPod からランク情報を取得`hyperpod_wait_rank_info()`するための呼び出し
+ **環境の更新**: HyperPod から受信したワーカー固有の環境変数を使用して、現在のプロセス環境を更新します。
**環境変数**
関数は、次の環境変数を読み取ります。
+ **RANK** (*int*) – 現在のプロセスランク (デフォルト: 設定されていない場合は -1)
+ **WORLD\$1SIZE** (*int*) – 分散ジョブ内のプロセスの合計数 (デフォルト: 設定されていない場合は 0)
**レイズ**
+ **AssertionError** – HyperPod からのレスポンスが想定どおりにない場合、または必須フィールドがない場合
**例**
```
from hyperpod_checkpointless_training.inprocess.train_utils import wait_rank
# Call before initializing distributed training
wait_rank()
# Now environment variables are properly set for this rank
import torch.distributed as dist
dist.init_process_group(backend='nccl')
```
**Notes** (メモ)
+ メインプロセスでのみ実行されます。サブプロセス呼び出しは自動的にスキップされます
+ HyperPod がランク情報を提供するまで、関数はブロックします
### HPWrapper
```
class hyperpod_checkpointless_training.inprocess.wrap.HPWrapper(
*,
abort=Compose(HPAbortTorchDistributed()),
finalize=None,
health_check=None,
hp_api_factory=None,
abort_timeout=None,
enabled=True,
trace_file_path=None,
async_raise_before_abort=True,
early_abort_communicator=False,
checkpoint_manager=None,
check_memory_status=True)
```
*HyperPod チェックポイントレストレーニングで再実行可能コードブロック (RCB) の再起動機能を有効にする Python 関数ラッパー。*
*このラッパーは、トレーニングの実行をモニタリングし、障害発生時に分散プロセス全体の再起動を調整することで、耐障害性と自動復旧機能を提供します。デコレータではなくコンテキストマネージャーアプローチを使用して、トレーニングライフサイクルを通じてグローバルリソースを維持します。*
**パラメータ**
+ **abort** (*中止*、*オプション*) – 障害が検出されると、実行を非同期的に中止します。デフォルト: `Compose(HPAbortTorchDistributed())`
+ **finalize** (*Finalize*、*オプション*) – 再起動時に実行されるランクローカルの finalize ハンドラー。デフォルト: `None`
+ **health\$1check** (*HealthCheck*、*オプション*) – 再起動時に実行されるランクローカルヘルスチェック。デフォルト: `None`
+ **hp\$1api\$1factory** (*呼び出し可能*、*オプション*) – HyperPod とやり取りするための HyperPod API を作成するためのファクトリー関数。デフォルト: `None`
+ **abort\$1timeout** (*浮動小数点*、*オプション*) – 障害制御スレッドでの中止呼び出しのタイムアウト。デフォルト: `None`
+ **enabled** (*bool*、*オプション*) – ラッパー機能を有効にします。の場合`False`、ラッパーはパススルーになります。デフォルト: `True`
+ **trace\$1file\$1path** (*str*、*オプション*) – VizTracer プロファイリングのトレースファイルへのパス。デフォルト: `None`
+ **async\$1raise\$1before\$1abort** (*bool*、*オプション*) – 障害制御スレッドで中止する前に raise を有効にします。デフォルト: `True`
+ **early\$1abort\$1communicator** (*bool*、*オプション*) – データローダーを中止する前にコミュニケーター (NCCL/Gloo) を中止します。デフォルト: `False`
+ **checkpoint\$1manager** (*任意*、*オプション*) – 復旧中にチェックポイントを処理するマネージャー。デフォルト: `None`
+ **check\$1memory\$1status** (*bool*、*オプション*) – メモリステータスのチェックとログ記録を有効にします。デフォルト: `True`
**方法**
```
def __call__(self, fn)
```
*関数をラップして再起動機能を有効にします。*
**パラメータ :**
+ **fn** (*呼び出し可能*) – 再起動機能でラップする関数
**戻り値:**
+ **呼び出し可能** – 再起動機能を備えたラップされた関数、または無効になっている場合は元の関数
**例**
```
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager
from hyperpod_checkpointless_training.nemo_plugins.patches import patch_megatron_optimizer
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector import CheckpointlessCompatibleConnector
from hyperpod_checkpointless_training.inprocess.train_utils import HPAgentK8sAPIFactory
from hyperpod_checkpointless_training.inprocess.abort import CheckpointlessFinalizeCleanup, CheckpointlessAbortManager
@HPWrapper(
health_check=CudaHealthCheck(),
hp_api_factory=HPAgentK8sAPIFactory(),
abort_timeout=60.0,
checkpoint_manager=CheckpointManager(enable_offload=False),
abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),
finalize=CheckpointlessFinalizeCleanup(),
)def training_function():
# Your training code here
pass
```
**Notes** (メモ)
+ ラッパーを使用可能に`torch.distributed`する必要があります
+ の場合`enabled=False`、ラッパーはパススルーになり、元の関数は変更されずに返されます。
+ ラッパーは、トレーニングライフサイクルを通じてスレッドのモニタリングなどのグローバルリソースを維持します。
+ `trace_file_path` が提供されているときに VizTracer プロファイリングをサポート
+ HyperPod と統合して、分散トレーニング全体で障害処理を調整
### HPCallWrapper
```
class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)
```
実行中にコードブロックの再起動 (RCB) の状態を監視および管理します。
このクラスは、障害検出、再起動のための他のランクとの調整、クリーンアップオペレーションなど、RCB 実行のライフサイクルを処理します。分散同期を管理し、すべてのトレーニングプロセスにわたって一貫した復旧を確保します。
**パラメータ**
+ **ラッパー** (*HPWrapper*) – グローバルプロセス内復旧設定を含む親ラッパー
**属性**
+ **step\$1upon\$1restart** (*int*) – 前回の再起動以降のステップを追跡するカウンター。再起動戦略の決定に使用されます。
**方法**
```
def initialize_barrier()
```
RCB から例外が発生した後、HyperPod 障壁の同期を待ちます。
```
def start_hp_fault_handling_thread()
```
障害のモニタリングと調整のために障害処理スレッドを起動します。
```
def handle_fn_exception(call_ex)
```
実行関数または RCB からの例外を処理します。
**パラメータ :**
+ **call\$1ex** (*例外*) – モニタリング関数からの例外
```
def restart(term_ex)
```
確定、ガベージコレクション、ヘルスチェックなどの再起動ハンドラーを実行します。
**パラメータ :**
+ **term\$1ex** (*RankShouldRestart*) — 再起動をトリガーする終了例外
```
def launch(fn, *a, **kw)
```
*適切な例外処理を使用して RCB を実行します。*
**パラメータ :**
+ **fn** (*呼び出し可能*) – 実行する関数
+ **a** – 関数引数
+ **kw** – 関数キーワード引数
```
def run(fn, a, kw)
```
再起動と障壁の同期を処理するメイン実行ループ。
**パラメータ :**
+ **fn** (*呼び出し可能*) – 実行する関数
+ **a** – 関数引数
+ **kw** – 関数キーワード引数
```
def shutdown()
```
障害処理とモニタリングスレッドをシャットダウンします。
**Notes** (メモ)
+ 調整された復旧の`RankShouldRestart`例外を自動的に処理する
+ メモリの追跡と中止、再起動中のガベージコレクションを管理します
+ 障害のタイミングに基づいて、プロセス内の復旧戦略と PLR (プロセスレベルの再起動) 戦略の両方をサポートします。
### CudaHealthCheck
```
class hyperpod_checkpointless_training.inprocess.health_check.CudaHealthCheck(timeout=datetime.timedelta(seconds=30))
```
チェックポイントレストレーニングの復旧中に、現在のプロセスの CUDA コンテキストが正常な状態であることを確認します。
このヘルスチェックは GPU と同期して、トレーニングの失敗後に CUDA コンテキストが破損していないことを確認します。GPU 同期オペレーションを実行して、トレーニングの再開が成功しない可能性のある問題を検出します。ヘルスチェックは、分散グループが破棄され、確定が完了した後に実行されます。
**パラメータ**
+ **timeout** (*datetime.timedelta*、*オプション*) – GPU 同期オペレーションのタイムアウト期間。デフォルト: `datetime.timedelta(seconds=30)`
**方法**
```
__call__(state, train_ex=None)
```
CUDA ヘルスチェックを実行して GPU コンテキストの整合性を検証します。
**パラメータ :**
+ **状態** (*HPState*) – ランクと分散情報を含む現在の HyperPod 状態
+ **train\$1ex** (*例外*、*オプション*) – 再起動をトリガーした元のトレーニング例外。デフォルト: `None`
**戻り値:**
+ **タプル** – ヘルスチェックに合格した場合に`(state, train_ex)`変更されない を含むタプル
**レイズ:**
+ **TimeoutError** – GPU 同期がタイムアウトし、破損した可能性のある CUDA コンテキストを示す場合
**状態の保存**: すべてのチェックに合格した場合、元の状態と例外は変更されません
**例**
```
import datetime
from hyperpod_checkpointless_training.inprocess.health_check import CudaHealthCheck
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
# Create CUDA health check with custom timeout
cuda_health_check = CudaHealthCheck(
timeout=datetime.timedelta(seconds=60)
)
# Use with HPWrapper for fault-tolerant training
@HPWrapper(
health_check=cuda_health_check,
enabled=True
)
def training_function():
# Your training code here
pass
```
**Notes** (メモ)
+ スレッディングを使用して GPU 同期のタイムアウト保護を実装
+ トレーニングの再開が成功しない可能性のある破損した CUDA コンテキストを検出するように設計されています。
+ 分散トレーニングシナリオで耐障害性パイプラインの一部として使用する必要があります
### HPAgentK8sAPIFactory
```
class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()
```
HyperPod インフラストラクチャと通信して分散トレーニングを調整する HPAgentK8sAPI インスタンスを作成するためのファクトリークラス。
このファクトリは、トレーニングプロセスと HyperPod コントロールプレーン間の通信を処理する HPAgentK8sAPI オブジェクトを作成および設定するための標準化された方法を提供します。基盤となるソケットクライアントと API インスタンスの作成をカプセル化し、トレーニングシステムのさまざまな部分で一貫した設定を確保します。
**方法**
```
__call__()
```
HyperPod 通信用に設定された HPAgentK8sAPI インスタンスを作成して返します。
**戻り値:**
+ **HPAgentK8sAPI** – HyperPod インフラストラクチャと通信するように設定された API インスタンス
**例**
```
from hyperpod_checkpointless_training.inprocess.train_utils import HPAgentK8sAPIFactory
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
from hyperpod_checkpointless_training.inprocess.health_check import CudaHealthCheck
# Create the factory
hp_api_factory = HPAgentK8sAPIFactory()
# Use with HPWrapper for fault-tolerant training
hp_wrapper = HPWrapper(
hp_api_factory=hp_api_factory,
health_check=CudaHealthCheck(),
abort_timeout=60.0,
enabled=True
)
@hp_wrapper
def training_function():
# Your distributed training code here
pass
```
**Notes** (メモ)
+ HyperPod の Kubernetes ベースのインフラストラクチャとシームレスに連携するように設計されています。分散トレーニングシナリオの調整された障害処理と復旧に不可欠です
### CheckpointManager
```
class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.CheckpointManager(
enable_checksum=False,
enable_offload=False)
```
分散トレーニングにおけるチェックポイントレス耐障害性のためのインメモリチェックポイントとpeer-to-peerリカバリを管理します。
このクラスは、メモリ内の NeMo モデルチェックポイントを管理し、復旧の実現可能性を検証し、正常なランクと失敗したランク間のpeer-to-peerチェックポイント転送を調整することで、HyperPod チェックポイントレストレーニングのコア機能を提供します。これにより、復旧中のディスク I/O が不要になり、平均復旧時間 (MTTR) が大幅に短縮されます。
**パラメータ**
+ **enable\$1checksum** (*bool*、*オプション*) – 復旧中の整合性チェックのモデル状態チェックサム検証を有効にします。デフォルト: `False`
+ **enable\$1offload** (*bool*、*オプション*) – GPU から CPU メモリへのチェックポイントオフロードを有効にして、GPU メモリの使用量を減らします。デフォルト: `False`
**属性**
+ **global\$1step** (*int* または *None*) – 保存されたチェックポイントに関連付けられた現在のトレーニングステップ
+ **rng\$1states** (*リスト*または*なし*) — 決定論的復旧のために保存された乱数ジェネレーターの状態
+ **checksum\$1manager** (*MemoryChecksumManager*) – モデル状態チェックサム検証用のマネージャー
+ **parameter\$1update\$1lock** (*ParameterUpdateLock*) – 復旧中のパラメータ更新を調整するためのロック
**方法**
```
save_checkpoint(trainer)
```
NeMo モデルチェックポイントをメモリに保存して、チェックポイントレスリカバリの可能性に備えます。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
**注意**:
+ バッチ終了時または例外処理中に CheckpointlessCallback によって呼び出されます
+ ディスク I/O オーバーヘッドなしで復旧ポイントを作成します
+ 完全なモデル、オプティマイザ、スケジューラの状態を保存します
```
delete_checkpoint()
```
インメモリチェックポイントを削除し、クリーンアップオペレーションを実行します。
**注意**:
+ チェックポイントデータ、RNG 状態、キャッシュされたテンソルをクリアします
+ ガベージコレクションと CUDA キャッシュのクリーンアップを実行します
+ 復旧が成功した後、またはチェックポイントが不要になったときに呼び出されます
```
try_checkpointless_load(trainer)
```
ピアランクから状態をロードしてチェックポイントレスリカバリを試行します。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) – PyTorch Lightning トレーナーインスタンス
**戻り値:**
+ **dict** または **None** – 成功した場合は復元されたチェックポイント、ディスクへのフォールバックが必要な場合はなし
**注意**:
+ チェックポイントレスリカバリの主なエントリポイント
+ P2P 転送を試みる前に復旧の実現可能性を検証します
+ 復旧の試行後、常にインメモリチェックポイントをクリーンアップする
```
checkpointless_recovery_feasible(trainer, include_checksum_verification=True)
```
現在の障害シナリオでチェックポイントレスリカバリが可能かどうかを確認します。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) – PyTorch Lightning トレーナーインスタンス
+ **include\$1checksum\$1verification** (*bool*、*オプション*) – チェックサム検証を含めるかどうか。デフォルト: `True`
**戻り値:**
+ **bool** – チェックポイントレスリカバリが可能であれば true、それ以外の場合は False
**検証基準:**
+ 正常なランク間のグローバルステップの一貫性
+ 復旧に使用できる十分な正常なレプリカ
+ モデル状態のチェックサムの整合性 (有効になっている場合)
```
store_rng_states()
```
決定論的復旧のために、すべての乱数ジェネレーターの状態を保存します。
**注意**:
+ Python、NumPy、PyTorch CPU/GPU、Megatron RNG の状態をキャプチャします
+ 復旧後のトレーニング決定性の維持に不可欠
```
load_rng_states()
```
確定的な復旧を継続するために、すべての RNG 状態を復元します。
**注意**:
+ 以前に保存したすべての RNG 状態を復元します
+ トレーニングが同一のランダムシーケンスで継続されるようにします
```
maybe_offload_checkpoint()
```
オフロードが有効になっている場合、チェックポイントを GPU から CPU メモリにオフロードします。
**注意**:
+ 大規模モデルの GPU メモリ使用量を削減
+ 次の場合にのみ実行されます。 `enable_offload=True`
+ 復旧のためのチェックポイントアクセシビリティを維持します
**例**
```
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager
# Use with HPWrapper for complete fault tolerance
@HPWrapper(
checkpoint_manager=CheckpointManager(),
enabled=True
)
def training_function():
# Training code with automatic checkpointless recovery
pass
```
**検証**: チェックサムを使用してチェックポイントの整合性を検証します (有効になっている場合)
**Notes** (メモ)
+ 分散通信プリミティブを使用して効率的な P2P 転送を実現
+ テンソルの dtype 変換とデバイスの配置を自動的に処理する
+ **MemoryChecksumManager** – モデル状態の整合性検証を処理します
### PEFTCheckpointManager
```
class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.PEFTCheckpointManager(
*args,
**kwargs)
```
チェックポイントレスリカバリを最適化するために、個別のベース処理とアダプター処理を使用して PEFT (パラメータ効率ファインチューニング) のチェックポイントを管理します。
この特殊なチェックポイントマネージャーは、CheckpointManager を拡張して、ベースモデルの重みをアダプターパラメータから分離することで PEFT ワークフローを最適化します。
**パラメータ**
**CheckpointManager** からすべてのパラメータを継承します。
+ **enable\$1checksum** (*bool*、*オプション*) – モデル状態チェックサムの検証を有効にします。デフォルト: `False`
+ **enable\$1offload** (*bool*、*オプション*) – CPU メモリへのチェックポイントオフロードを有効にします。デフォルト: `False`
**追加の属性**
+ **params\$1to\$1save** (*セット*) – アダプターパラメータとして保存する必要があるパラメータ名のセット
+ **base\$1model\$1weights** (*dict* または *None*) – キャッシュされたベースモデルの重み、一度保存して再利用
+ **base\$1model\$1keys\$1to\$1extract** (*リスト*または*なし*) – P2P 転送中にベースモデルテンソルを抽出するためのキー
**方法**
```
maybe_save_base_model(trainer)
```
アダプターパラメータを除外して、ベースモデルの重みを 1 回保存します。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) – PyTorch Lightning トレーナーインスタンス
**注意**:
+ 最初の呼び出し時にのみベースモデルの重みを保存します。後続の呼び出しは no-ops です。
+ アダプターパラメータをフィルタリングして、フリーズしたベースモデルの重みのみを保存します
+ 基本モデルの重みは複数のトレーニングセッションにわたって保持されます
```
save_checkpoint(trainer)
```
NeMo PEFT アダプターモデルのチェックポイントをメモリに保存して、チェックポイントレスリカバリの可能性に備えます。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
**注意**:
+ ベースモデルがまだ保存されていない場合`maybe_save_base_model()`に を自動的に呼び出す
+ アダプターパラメータとトレーニング状態のみを含めるようにチェックポイントをフィルタリングします
+ 完全なモデルチェックポイントと比較してチェックポイントサイズを大幅に削減
```
try_base_model_checkpointless_load(trainer)
```
ピアランクから状態をロードして、PEFT ベースモデルの重み付けチェックポイントレスリカバリを試みます。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) – PyTorch Lightning トレーナーインスタンス
**戻り値:**
+ **dict** または **None** – 成功した場合はベースモデルチェックポイントを復元し、フォールバックが必要な場合はなし
**注意**:
+ 基本モデルの重みを回復するためにモデルの初期化中に使用される
+ 復旧後にベースモデルの重みをクリーンアップしない (再利用のために保存)
+ model-weights-only復旧シナリオ向けに最適化
```
try_checkpointless_load(trainer)
```
PEFT アダプターを試行すると、ピアランクから状態をロードしてチェックポイントレスリカバリが重み付けされます。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
**戻り値:**
+ **dict** または **None** – 成功した場合はアダプターチェックポイントを復元し、フォールバックが必要な場合はなし
**注意**:
+ アダプターパラメータ、オプティマイザの状態、スケジューラのみを復旧します
+ 復旧に成功すると、オプティマイザとスケジューラの状態を自動的にロードします
+ 復旧の試行後にアダプターチェックポイントをクリーンアップします
```
is_adapter_key(key)
```
状態ディクトキーがアダプターパラメータに属しているかどうかを確認します。
**パラメータ :**
+ **key** (*str* または*タプル*) — チェックするステートディクトキー
**戻り値:**
+ **bool** – key がアダプターパラメータの場合は true、base model パラメータの場合は False
**検出ロジック:**
+ キーが設定されているかどうかを確認します `params_to_save`
+ ".adapter" を含むキーを識別します。substring
+ 「.adapters」で終わるキーを識別します
+ タプルキーの場合、 パラメータに勾配が必要かどうかを確認します
```
maybe_offload_checkpoint()
```
ベースモデルの重みを GPU から CPU メモリにオフロードします。
**注意**:
+ 親メソッドを拡張してベースモデルのウェイトオフロードを処理します
+ アダプターの重みは通常小さく、オフロードは必要ありません
+ オフロード状態を追跡する内部フラグを設定します
**Notes** (メモ)
+ パラメータ効率の高いファインチューニングシナリオ (LoRA、アダプターなど) 向けに特別に設計
+ ベースモデルとアダプターパラメータの分離を自動的に処理します
**例**
```
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import PEFTCheckpointManager
# Use with HPWrapper for complete fault tolerance
@HPWrapper(
checkpoint_manager=PEFTCheckpointManager(),
enabled=True
)
def training_function():
# Training code with automatic checkpointless recovery
pass
```
### CheckpointlessAbortManager
```
class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessAbortManager()
```
チェックポイントレス耐障害性のための中止コンポーネント構成を作成および管理するためのファクトリークラス。
このユーティリティクラスは、HyperPod チェックポイントレストレーニングの障害処理中に使用される中止コンポーネントコンポジションを作成、カスタマイズ、管理する静的メソッドを提供します。これにより、障害復旧中の分散トレーニングコンポーネント、データローダー、フレームワーク固有のリソースのクリーンアップを処理する中止シーケンスの設定が簡素化されます。
**パラメータ**
なし (すべてのメソッドは静的)
**静的メソッド**
```
get_default_checkpointless_abort()
```
すべての標準中止コンポーネントを含むデフォルトの中止構成インスタンスを取得します。
**戻り値:**
+ **Compose** – すべての中止コンポーネントを含むデフォルトの構成中止インスタンス
**デフォルトコンポーネント:**
+ **AbortTransformerEngine()** – TransformerEngine リソースをクリーンアップします
+ **HPCheckpointingAbort()** – チェックポイントシステムのクリーンアップを処理します
+ **HPAbortTorchDistributed()** – PyTorch 分散オペレーションを中止
+ **HPDataLoaderAbort()** – データローダーを停止してクリーンアップします
```
create_custom_abort(abort_instances)
```
*指定された中止インスタンスのみを使用してカスタム中止構成を作成します。*
**パラメータ :**
+ **abort\$1instances** (*中止*) – 構成に含める中止インスタンスの可変数
**戻り値:**
+ **Compose** – 指定されたコンポーネントのみを含む新しい構成中止インスタンス
**レイズ:**
+ **ValueError** – 中止インスタンスが指定されていない場合
```
override_abort(abort_compose, abort_type, new_abort)
```
Compose インスタンス内の特定の中止コンポーネントを新しいコンポーネントに置き換えます。
**パラメータ :**
+ **abort\$1compose** (*Compose*) – 変更する元の Compose インスタンス
+ **abort\$1type** (*タイプ*) – 置き換える中止コンポーネントのタイプ (例: `HPCheckpointingAbort`)
+ **new\$1abort** (*中止*) – 置き換えとして使用する新しい中止インスタンス
**戻り値:**
+ **Compose** – 指定されたコンポーネントが置き換えられた新しい Compose インスタンス
**レイズ:**
+ **ValueError** – abort\$1compose に「インスタンス」属性がない場合
**例**
```
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback
from hyperpod_checkpointless_training.inprocess.abort import CheckpointlessFinalizeCleanup, CheckpointlessAbortManager
# The strategy automatically integrates with HPWrapper
@HPWrapper(
abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),
health_check=CudaHealthCheck(),
finalize=CheckpointlessFinalizeCleanup(),
enabled=True
)
def training_function():
trainer.fit(...)
```
**Notes** (メモ)
+ カスタム設定により、クリーンアップ動作を微調整できます。
+ 障害復旧中の適切なリソースクリーンアップには、オペレーションの中止が不可欠です
### CheckpointlessFinalizeCleanup
```
class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()
```
障害検出後に包括的なクリーンアップを実行し、チェックポイントレストレーニング中の処理中の復旧に備えます。
このファイナライズハンドラーは、トレーニングコンポーネントの参照を破棄することで、Megatron/TransformerEngine 中止、DDP クリーンアップ、モジュール再ロード、メモリクリーンアップなどのフレームワーク固有のクリーンアップオペレーションを実行します。これにより、完全なプロセス終了を必要とせずに、トレーニング環境が適切にリセットされ、プロセス内の復旧が成功します。
**パラメータ**
なし
**属性**
+ **トレーナー** (*pytorch\$1lightning.Trainer* または *None*) — PyTorch Lightning トレーナーインスタンスへの参照
**方法**
```
__call__(*a, **kw)
```
**プロセス内の復旧準備のための包括的なクリーンアップオペレーションを実行します。**
*パラメータ :*
+ **a** – 可変位置引数 (Finalize インターフェイスから継承)
+ **kw** – 変数キーワード引数 (Finalize インターフェイスから継承)
**クリーンアップオペレーション:**
+ **Megatron Framework Cleanup** – Megatron 固有のリソースをクリーンアップ`abort_megatron()`するための呼び出し
+ **TransformerEngine クリーンアップ** – TransformerEngine リソースをクリーンアップ`abort_te()`するための呼び出し
+ **RoPE クリーンアップ** – 回転位置埋め込みリソースをクリーンアップ`cleanup_rope()`するための呼び出し
+ **DDP クリーンアップ** – DistributedDataParallel リソースをクリーンアップ`cleanup_ddp()`するための呼び出し
+ **モジュールのリロード** — フレームワークモジュールを再ロード`reload_megatron_and_te()`するための呼び出し
+ **Lightning Module Cleanup** – オプションで Lightning モジュールをクリアして GPU メモリを削減
+ **メモリクリーンアップ** — トレーニングコンポーネントのリファレンスを空きメモリに破棄します
```
register_attributes(trainer)
```
*クリーンアップ操作中に使用するトレーナーインスタンスを登録します。*
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — 登録する PyTorch Lightning トレーナーインスタンス
**CheckpointlessCallback との統合**
```
from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
# The strategy automatically integrates with HPWrapper
@HPWrapper(
...
finalize=CheckpointlessFinalizeCleanup(),
)
def training_function():
trainer.fit(...)
```
**Notes** (メモ)
+ クリーンアップオペレーションは、依存関係の問題を回避するために特定の順序で実行されます。
+ メモリクリーンアップでは、ガベージコレクションのイントロスペクションを使用してターゲットオブジェクトを検索します。
+ すべてのクリーンアップオペレーションは冪等性があり、安全に再試行できるように設計されています
### CheckpointlessMegatronStrategy
```
class hyperpod_checkpointless_training.nemo_plugins.megatron_strategy.CheckpointlessMegatronStrategy(*args, **kwargs)
```
NeMo Megatron 戦略は、耐障害性のある分散トレーニングのための統合されたチェックポイントレスリカバリ機能を備えています。
チェックポイントレストレーニングでは`num_distributed_optimizer_instances`、オプティマイザレプリケーションが行われるように 2 以上が必要です。この戦略では、必須属性の登録とプロセスグループの初期化も行います。
**パラメータ**
**MegatronStrategy** からすべてのパラメータを継承します。
+ 標準 NeMo MegatronStrategy 初期化パラメータ
+ 分散トレーニング設定オプション
+ モデル並列処理の設定
**属性**
+ **base\$1store** (*torch.distributed.TCPStore* または *None*) – プロセスグループ調整用の分散ストア
**方法**
```
setup(trainer)
```
戦略を初期化し、耐障害性コンポーネントをトレーナーに登録します。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
**セットアップオペレーション:**
+ **親セットアップ** – 親 MegatronStrategy セットアップを呼び出します
+ **フォールトインジェクション登録** — 存在する場合は HPFaultInjectionCallback フックを登録します
+ **登録の確定** – トレーナーをクリーンアップハンドラーの確定に登録します
+ **登録の中止 – **登録をサポートする中止ハンドラーにトレーナーを登録します
```
setup_distributed()
```
プレフィックス付き TCPStore またはルートレス接続を使用してプロセスグループを初期化します。
```
load_model_state_dict(checkpoint, strict=True)
```
チェックポイントレスリカバリの互換性があるロードモデルステートディクト。
**パラメータ :**
+ **チェックポイント** (*Mapping[str, Any]*) – モデル状態を含むチェックポイントディクショナリ
+ **strict** (*bool*、*オプション*) – ステートディクットキーマッチングを厳密に適用するかどうか。デフォルト: `True`
```
get_wrapper()
```
耐障害性の調整のために HPCallWrapper インスタンスを取得します。
**戻り値:**
+ **HPCallWrapper** – 耐障害性のためにトレーナーにアタッチされたラッパーインスタンス
```
is_peft()
```
PEFT コールバックをチェックして、トレーニング設定で PEFT (パラメータ効率ファインチューニング) が有効になっているかどうかを確認します。
**戻り値:**
+ **bool** – PEFT コールバックが存在する場合は true、それ以外の場合は False
```
teardown()
```
PyTorch Lightning ネイティブのティアダウンを上書きして、ハンドラーを中止するクリーンアップを委任します。
**例**
```
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper
# The strategy automatically integrates with HPWrapper
@HPWrapper(
checkpoint_manager=checkpoint_manager,
enabled=True
)
def training_function():
trainer = pl.Trainer(strategy=CheckpointlessMegatronStrategy())
trainer.fit(model, datamodule)
```
### CheckpointlessCallback
```
class hyperpod_checkpointless_training.nemo_plugins.callbacks.CheckpointlessCallback(
enable_inprocess=False,
enable_checkpointless=False,
enable_checksum=False,
clean_tensor_hook=False,
clean_lightning_module=False)
```
NeMo トレーニングをチェックポイントレストレーニングの耐障害性システムと統合する Lightning コールバック。
このコールバックは、ステップの追跡、チェックポイントの保存、およびパラメータ更新の調整を管理して、処理中の復旧機能を実現します。PyTorch Lightning トレーニングループと HyperPod チェックポイントレストレーニングメカニズム間の主要な統合ポイントとして機能し、トレーニングライフサイクル全体で耐障害性オペレーションを調整します。
**パラメータ**
+ **enable\$1inprocess** (*bool*、*オプション*) – 処理中の復旧機能を有効にします。デフォルト: `False`
+ **enable\$1checkpointless** (*bool*、*オプション*) – チェックポイントレスリカバリを有効にします ( が必要です`enable_inprocess=True`)。デフォルト: `False`
+ **enable\$1checksum** (*bool*、*オプション*) – モデル状態チェックサム検証を有効にします ( が必要です`enable_checkpointless=True`)。デフォルト: `False`
+ **clean\$1tensor\$1hook** (*bool*、*オプション*) – クリーンアップ (高価なオペレーション) 中にすべての GPU テンソルからテンソルフックをクリアします。デフォルト: `False`
+ **clean\$1lightning\$1module** (*bool*、*オプション*) – 再起動のたびに Lightning モジュールのクリーンアップを有効にして GPU メモリを解放します。デフォルト: `False`
**属性**
+ **tried\$1adapter\$1checkpointless** (*bool*) – アダプターチェックポイントレス復元が試行されたかどうかを追跡するフラグ
**方法**
```
get_wrapper_from_trainer(trainer)
```
耐障害性の調整のために、トレーナーから HPCallWrapper インスタンスを取得します。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
**戻り値:**
+ **HPCallWrapper** – 耐障害性オペレーション用のラッパーインスタンス
```
on_train_batch_start(trainer, pl_module, batch, batch_idx, *args, **kwargs)
```
ステップの追跡と復旧を管理するために、各トレーニングバッチの開始時に呼び出されます。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
+ **pl\$1module** (*pytorch\$1lightning.LightningModule*) – トレーニング中の稲妻モジュール
+ **batch** – 現在のトレーニングバッチデータ
+ **batch\$1idx** (*int*) – 現在のバッチのインデックス
+ **args** – 追加の位置引数
+ **kwargs** – 追加のキーワード引数
```
on_train_batch_end(trainer, pl_module, outputs, batch, batch_idx)
```
*各トレーニングバッチの最後にパラメータ更新ロックを解放します。*
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) — PyTorch Lightning トレーナーインスタンス
+ **pl\$1module** (*pytorch\$1lightning.LightningModule*) – トレーニング中の稲妻モジュール
+ **出力** (*STEP\$1OUTPUT*) – トレーニングステップ出力
+ **batch** (*Any*) – 現在のトレーニングバッチデータ
+ **batch\$1idx** (*int*) – 現在のバッチのインデックス
**注意**:
+ ロックリリースタイミングにより、パラメータの更新が完了した後にチェックポイントレスリカバリを続行できます。
+ `enable_inprocess` と の両方`enable_checkpointless`が True の場合にのみ実行されます。
```
get_peft_callback(trainer)
```
*トレーナーのコールバックリストから PEFT コールバックを取得します。*
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) – PyTorch Lightning トレーナーインスタンス
**戻り値:**
+ **PEFT** または **None** – 見つかった場合は PEFT コールバックインスタンス、それ以外の場合はなし
```
_try_adapter_checkpointless_restore(trainer, params_to_save)
```
*PEFT アダプターパラメータのチェックポイントレス復元を試行します。*
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer*) – PyTorch Lightning トレーナーインスタンス
+ **params\$1to\$1save** (*セット*) – アダプターパラメータとして保存するパラメータ名のセット
**注意**:
+ トレーニングセッションごとに 1 回のみ実行されます ( `tried_adapter_checkpointless` フラグで制御)
+ アダプターパラメータ情報を使用してチェックポイントマネージャーを設定します
**例**
```
from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager
import pytorch_lightning as pl
# Create checkpoint manager
checkpoint_manager = CheckpointManager(
enable_checksum=True,
enable_offload=True
)
# Create checkpointless callback with full fault tolerance
checkpointless_callback = CheckpointlessCallback(
enable_inprocess=True,
enable_checkpointless=True,
enable_checksum=True,
clean_tensor_hook=True,
clean_lightning_module=True
)
# Use with PyTorch Lightning trainer
trainer = pl.Trainer(
callbacks=[checkpointless_callback],
strategy=CheckpointlessMegatronStrategy()
)
# Training with fault tolerance
trainer.fit(model, datamodule=data_module)
```
** メモリ管理 **
+ **clean\$1tensor\$1hook**: クリーンアップ中にテンソルフックを削除します (高価ですが徹底的)
+ **clean\$1lightning\$1module**: 再起動中に Lightning モジュール GPU メモリを解放します
+ どちらのオプションも、障害復旧中のメモリフットプリントの削減に役立ちます。
+ ParameterUpdateLock との調整によるスレッドセーフなパラメータ更新の追跡
### CheckpointlessCompatibleConnector
```
class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()
```
チェックポイントレスリカバリを従来のディスクベースのチェックポイントロードと統合する PyTorch Lightning チェックポイントコネクタ。
このコネクタは PyTorch Lightning を拡張`_CheckpointConnector`して、チェックポイントレスリカバリと標準チェックポイント復元の間のシームレスな統合を提供します。最初にチェックポイントレスリカバリを試行し、チェックポイントレスリカバリが実行可能でない場合や失敗した場合はディスクベースのチェックポイントロードにフォールバックします。
**パラメータ**
**\$1CheckpointConnector** からすべてのパラメータを継承します
**方法**
```
resume_start(checkpoint_path=None)
```
チェックポイントレスリカバリの優先度でチェックポイントをプリロードしようとします。
**パラメータ :**
+ **checkpoint\$1path** (*str* または *None*、*オプション*) – フォールバック用のディスクチェックポイントへのパス。デフォルト: `None`
```
resume_end()
```
チェックポイントのロードプロセスを完了し、ロード後のオペレーションを実行します。
**Notes** (メモ)
+ チェックポイントレスリカバリのサポートにより PyTorch Lightning の内部`_CheckpointConnector`クラスを拡張
+ 標準の PyTorch Lightning チェックポイントワークフローとの完全な互換性を維持します
### CheckpointlessAutoResume
```
class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()
```
NeMo の AutoResume を遅延セットアップで拡張し、チェックポイントパス解決前のチェックポイントレス復旧検証を有効にします。
このクラスは、従来のディスクベースのチェックポイントロードにフォールバックする前にチェックポイントレスリカバリ検証を実行できるようにする 2 フェーズの初期化戦略を実装します。これにより、AutoResume のセットアップが条件付きで遅延され、チェックポイントパスの早期解決が防止されます。これにより、CheckpointManager はまずチェックポイントレスpeer-to-peerリカバリが実行可能かどうかを検証できます。
**パラメータ**
**AutoResume** からすべてのパラメータを継承します
**方法**
```
setup(trainer, model=None, force_setup=False)
```
AutoResume のセットアップを条件付きで遅らせて、チェックポイントレスリカバリの検証を有効にします。
**パラメータ :**
+ **トレーナー** (*pytorch\$1lightning.Trainer* または*Lightning.fabric.Fabric*) – PyTorch Lightning トレーナーまたは Fabric インスタンス
+ **model** (*オプション*) – セットアップ用のモデルインスタンス。デフォルト: `None`
+ **force\$1setup** (*bool*、*オプション*) – True の場合、遅延をバイパスして AutoResume セットアップをすぐに実行します。デフォルト: `False`
**例**
```
from hyperpod_checkpointless_training.nemo_plugins.resume import CheckpointlessAutoResume
from hyperpod_checkpointless_training.nemo_plugins.megatron_strategy import CheckpointlessMegatronStrategy
import pytorch_lightning as pl
# Create trainer with checkpointless auto-resume
trainer = pl.Trainer(
strategy=CheckpointlessMegatronStrategy(),
resume=CheckpointlessAutoResume()
)
```
**Notes** (メモ)
+ チェックポイントレスリカバリを有効にする遅延メカニズムを使用して NeMo の AutoResume クラスを拡張
+ と連動`CheckpointlessCompatibleConnector`して完全な復旧ワークフローを実現