Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Formazione senza checkpointless in Amazon SageMaker HyperPod
La formazione Checkpointless su Amazon SageMaker HyperPod consente un ripristino più rapido dai guasti dell'infrastruttura di formazione. La seguente documentazione ti aiuta a iniziare con la formazione senza checkpoint e la messa a punto per i modelli supportati. NeMo
La formazione Checkpointless ha i seguenti prerequisiti:
+ [Inizia a usare il supporto di Amazon EKS in SageMaker HyperPod](sagemaker-hyperpod-eks-prerequisites.md)
+ [Installazione dell’operatore di addestramento](sagemaker-eks-operator-install.md). È necessario installare la versione 1.2.0 o successiva.
Checkpointless training on SageMaker HyperPod si basa sulla Guida per l'utente di [ NeMo NVIDIA](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/core/exp_manager.html#experiment-manager) Framework. Puoi eseguire corsi di formazione senza checkpointless con ricette precreate. SageMaker HyperPod Se le conosci NeMo, il processo di utilizzo delle ricette di formazione senza checkpoint è simile. Con piccole modifiche, puoi iniziare ad addestrare un modello utilizzando funzionalità di allenamento senza checkpoint che ti consentono di recuperare rapidamente dagli errori di allenamento.
Le seguenti HyperPod ricette sono preconfigurate con ottimizzazioni dell'allenamento senza checkpoint. Puoi specificare i percorsi dei dati come parte della ricetta e utilizzare lo script di avvio associato per eseguire la formazione (consulta la guida rapida di avvio di seguito):
| Modello | Metodo | Dimensione | Nodi | Istanza | Accelerator | Recipe | Script | Tutorial |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPT OSS | Esempio completo di finetune | 120 g | 16 | p5.48xlarge | GPU H100 | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/gpt_oss/checkpointless_gpt_oss_120b_full_fine_tuning.yaml) | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/launcher_scripts/gpt_oss/run_checkpointless_gpt_oss_120b_full_fine_tuning.sh) | [collegamento](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-finetune.html) |
| GPT BOSS | Esempio di LoRa | 120 b | 2 | p5.48xlarge | GPU H100 | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/gpt_oss/checkpointless_gpt_oss_120b_lora.yaml) | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/launcher_scripts/gpt_oss/run_checkpointless_gpt_oss_120b_lora.sh) | [collegamento](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-peft.html) |
| Lama 3 | Esempio di pre-allenamento | 70 b | 16 | p5.48xlarge | GPU H100 | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/training/llama/checkpointless_llama3_70b_pretrain.yaml) | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/launcher_scripts/llama/run_checkpointless_llama3_70b_pretrain.sh) | [collegamento](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-pretraining-llama3.html) |
| Lama 3 | Esempio di Lora | 70 b | 2 | p5.48xlarge | GPU H100 | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/llama/checkpointless_llama3_70b_lora.yaml) | [collegamento](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/launcher_scripts/llama/run_checkpointless_llama3_70b_lora.sh) | [collegamento](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-peft-llama.html) |
La seguente guida rapida fornisce tutorial per l'utilizzo di ricette di formazione senza checkpoint:
**Esempi introduttivi**
+ [Tutorial - Ottimizzazione completa di Amazon SageMaker HyperPod Checkpointless GPT OSS 120b](sagemaker-eks-checkpointless-recipes-finetune.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless Left-LoRa GPT OSS 120b](sagemaker-eks-checkpointless-recipes-peft.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless Pretraining Llama 3 70b](sagemaker-eks-checkpointless-recipes-pretraining-llama3.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless Left-Lora Llama 3 70b](sagemaker-eks-checkpointless-recipes-peft-llama.md)
Se desideri pre-addestrare o perfezionare i modelli personalizzati, consulta. [Tutorial - Amazon SageMaker HyperPod Checkpointless, preaddestramento o messa a punto di modelli personalizzati](sagemaker-eks-checkpointless-recipes-custom.md)
Per ulteriori informazioni sull'integrazione di componenti di formazione specifici senza checkpoint,. [HyperPod funzionalità di formazione senza checkpointless](sagemaker-eks-checkpointless-features.md)
# Tutorial di formazione SageMaker HyperPod senza checkpoint su Amazon
[ HyperPod Le ricette di formazione checkpointless](https://github.com/aws/sagemaker-hyperpod-checkpointless-training) sono configurazioni di lavoro predefinite con funzionalità di formazione senza checkpointless abilitate. L'utilizzo di queste ricette semplifica l'avvio di corsi di formazione senza checkpoint. HyperPod
**Topics**
+ [Tutorial - Ottimizzazione completa di Amazon SageMaker HyperPod Checkpointless GPT OSS 120b](sagemaker-eks-checkpointless-recipes-finetune.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless Left-LoRa GPT OSS 120b](sagemaker-eks-checkpointless-recipes-peft.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless Pretraining Llama 3 70b](sagemaker-eks-checkpointless-recipes-pretraining-llama3.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless Left-Lora Llama 3 70b](sagemaker-eks-checkpointless-recipes-peft-llama.md)
+ [Tutorial - Amazon SageMaker HyperPod Checkpointless, preaddestramento o messa a punto di modelli personalizzati](sagemaker-eks-checkpointless-recipes-custom.md)
# Tutorial - Ottimizzazione completa di Amazon SageMaker HyperPod Checkpointless GPT OSS 120b
La seguente sequenza di passaggi è necessaria per eseguire ricette di formazione senza checkpoint. HyperPod
## Prerequisiti
Prima di iniziare a configurare l’ambiente, assicurati di avere:
+ [Supporto Amazon EKS abilitato in Amazon SageMaker HyperPod](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-prerequisites.html)
+ [Configura l'operatore HyperPod di formazione (v1.2\$1)](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html)
+ Una posizione di archiviazione condivisa. Può essere un FSx file system Amazon o un sistema NFS accessibile dai nodi del cluster.
+ I dati in uno dei seguenti formati:
+ JSON
+ JSONGZ (JSON compresso)
+ ARROW
+ [Scegli una ricetta di formazione supportata senza checkpoint per Llama 70B o GPT-OSS 120B dalla fonte.](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
+ [Scaricate i pesi del modello Hugging](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) [Face e convertiteli nel formato supportato da Nemo.](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemo-2.0/features/hf-integration.html#importing-from-hugging-face)
+ Configurare l’ambiente
## Configurazione dell'ambiente Kubernetes
Per configurare l'ambiente Kubernetes, procedi come segue:
1. Configura l’ambiente virtuale. Assicurati che la tua versione di Python sia maggiore o uguale a 3.10 e inferiore a 3.14.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. [Configura kubectl ed eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
1. [Installa Helm](https://helm.sh/docs/intro/install/)
1. Connettiti al cluster Kubernetes.
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
```
1. Installa le dipendenze utilizzando uno dei metodi seguenti:
1. Metodo 1: metodo SageMaker HyperPod delle ricette:
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
1. Metodo 2: kubectl con metodo job yaml predefinito
```
# install SageMaker HyperPod checkpointless training.
git clone git@github.com:aws/sagemaker-hyperpod-checkpointless-training.git
cd sagemaker-hyperpod-checkpointless-training
```
Ora puoi lanciare la ricetta di allenamento senza checkpointless usando il programma di avvio -style o usando kubectl. NeMo
## Avvia i lavori di formazione con il programma di avvio delle ricette
Puoi utilizzare le SageMaker HyperPod ricette di Amazon per inviare il tuo lavoro di formazione. L'utilizzo delle ricette comporta l'aggiornamento di k8s.yaml, config.yaml e l'esecuzione dello script di avvio.
1. Aggiornamento di `launcher_scripts/gpt_oss/run_checkpointless_gpt_oss_120b_full_fine_tuning.sh`
your\$1container: Un contenitore di Deep Learning. Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di [checkpointless](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) training.
```
#!/bin/bash
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
TRAIN_DIR="${TRAIN_DIR}"
VAL_DIR="${VAL_DIR}"
EXP_DIR="${EXP_DIR}"
LOG_DIR="${LOG_DIR}"
CONTAINER_MOUNT="/data"
CONTAINER="${CONTAINER}"
MODEL_NAME_OR_PATH="${MODEL_NAME_OR_PATH}"
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=fine-tuning/gpt_oss/checkpointless_gpt_oss_120b_full_fine_tuning \
recipes.dataset.dataset_path="${TRAIN_DIR}" \
recipes.exp_manager.exp_dir="${EXP_DIR}" \
recipes.log_dir="${LOG_DIR}" \
recipes.resume.restore_config.path="${MODEL_NAME_OR_PATH}" \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
git.use_default=false \
cluster=k8s \
cluster_type=k8s \
container="${CONTAINER}" \
+cluster.hostNetwork=true \
+cluster.persistent_volume_claims.0.claimName=fsx-claim \
+cluster.persistent_volume_claims.0.mountPath="${CONTAINER_MOUNT}" \
+recipes.dataset.val_dataset_path="${VAL_DIR}" \
++recipes.callbacks.3.test_fault_config.fault_prob_between_lock=1 \
```
1. Avvio del job di addestramento
```
bash launcher_scripts/gpt_oss/run_checkpointless_gpt_oss_120b_full_fine_tuning.sh
```
Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
gpt-oss-120b-worker-0 0/1 running 0 36s
```
Se lo STATUS è in sospeso o ContainerCreating, esegui il comando seguente per ottenere maggiori dettagli
```
kubectl describe pod
```
Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
`STATUS` diventa `COMPLETED` quando esegui `kubectl get pods`.
## Avvia il processo di formazione con kubectl con yaml predefinito
Un'altra opzione è avviare la formazione tramite kubectl con un job predefinito yaml.
1. aggiorna examples/gpt\$1oss/launch/full \$1finetune\$1gpt\$1oss\$1120b\$1checkpointless\$1p5.yaml
+ immagine: Un contenitore di Deep Learning. Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di [checkpointless](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) training.
+ [resume.restore\$1config.path=: il percorso per scaricare i pesi dei modelli preaddestrati in formato Nemo nella fase Prerequisiti.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-finetune.html#sagemaker-eks-checkpointless-recipes-finetune-prereqs)
+ dataset.dataset\$1path=: il percorso del set di dati archiviato nella memoria condivisa
1. Invia il lavoro usando kubectl con full\$1finetune\$1gpt\$1oss\$1120b\$1checkpointless\$1p5.yaml
```
kubectl apply -f examples/gpt_oss/launch/full_finetune_gpt_oss_120b_checkpointless_p5.yaml
```
Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
gpt-oss-120b-worker-0 0/1 running 0 36s
```
Se lo STATUS è in sospeso o, esegui il seguente comando per ottenere maggiori dettagli ContainerCreating
```
kubectl describe pod
```
Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
# Tutorial - Amazon SageMaker HyperPod Checkpointless Left-LoRa GPT OSS 120b
La seguente sequenza di passaggi è necessaria per eseguire ricette di formazione senza checkpoint. HyperPod
## Prerequisiti
Prima di iniziare a configurare l’ambiente, assicurati di avere:
+ [Supporto Amazon EKS abilitato in Amazon SageMaker HyperPod](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-prerequisites.html)
+ [Configura l'operatore HyperPod di formazione (v1.2\$1)](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html)
+ Una posizione di archiviazione condivisa. Può essere un FSx file system Amazon o un sistema NFS accessibile dai nodi del cluster.
+ I dati in uno dei seguenti formati:
+ JSON
+ JSONGZ (JSON compresso)
+ ARROW
+ [Scegli una ricetta di formazione supportata senza checkpoint per Llama 70B o GPT-OSS 120B dalla fonte.](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
+ [Scaricate i pesi del modello Hugging](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) [Face e convertiteli nel formato supportato da Nemo.](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemo-2.0/features/hf-integration.html#importing-from-hugging-face)
+ Configurare l’ambiente
## Configurazione dell'ambiente Kubernetes
Per configurare l'ambiente Kubernetes, procedi come segue:
1. Configura l’ambiente virtuale. Assicurati di usare Python maggiore o uguale a 3.10 e < 3.14.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. [Configura kubectl ed eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
1. [Installa Helm](https://helm.sh/docs/intro/install/)
1. Connettiti al cluster Kubernetes.
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
```
1. Installa le dipendenze utilizzando uno dei metodi seguenti:
+ SageMaker HyperPod metodo delle ricette:
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ kubectl con metodo job yaml predefinito
```
# install SageMaker HyperPod checkpointless training.
git clone git@github.com:aws/sagemaker-hyperpod-checkpointless-training.git
cd sagemaker-hyperpod-checkpointless-training
```
Ora puoi lanciare la ricetta di allenamento senza checkpointless usando il programma di avvio -style o usando kubectl. NeMo
## Avvio del job di addestramento con l’utilità di avvio delle ricette
In alternativa, puoi utilizzare le SageMaker HyperPod ricette per inviare il tuo lavoro di formazione. L'uso delle ricette comporta l'aggiornamento di k8s.yaml, config.yaml e l'esecuzione dello script di avvio.
1. Aggiornamento di `launcher_scripts/gpt_oss/run_checkpointless_gpt_oss_120b_lora.sh`
your\$1contrainer: un contenitore di Deep Learning. [Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di checkpointless training.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html)
```
#!/bin/bash
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
TRAIN_DIR="${TRAIN_DIR}"
VAL_DIR="${VAL_DIR}"
EXP_DIR="${EXP_DIR}"
LOG_DIR="${LOG_DIR}"
CONTAINER_MOUNT="/data"
CONTAINER="${CONTAINER}"
MODEL_NAME_OR_PATH="${MODEL_NAME_OR_PATH}"
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=fine-tuning/gpt_oss/checkpointless_gpt_oss_120b_lora \
recipes.dataset.dataset_path="${TRAIN_DIR}" \
recipes.exp_manager.exp_dir="${EXP_DIR}" \
recipes.log_dir="${LOG_DIR}" \
recipes.resume.restore_config.path="${MODEL_NAME_OR_PATH}" \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
git.use_default=false \
cluster=k8s \
cluster_type=k8s \
container="${CONTAINER}" \
+cluster.hostNetwork=true \
+cluster.persistent_volume_claims.0.claimName=fsx-claim \
+cluster.persistent_volume_claims.0.mountPath="${CONTAINER_MOUNT}" \
+recipes.dataset.val_dataset_path="${VAL_DIR}" \
++recipes.callbacks.3.test_fault_config.fault_prob_between_lock=1 \
```
1. Avvio del job di addestramento
```
bash launcher_scripts/gpt_oss/run_checkpointless_gpt_oss_120b_lora.sh
```
Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
gpt-oss-120b-worker-0 0/1 running 0 36s
```
Se lo STATUS è in sospeso o ContainerCreating, esegui il comando seguente per ottenere maggiori dettagli
```
kubectl describe pod
```
Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
## Avvia il processo di formazione con kubectl con yaml predefinito
Un'altra opzione è avviare la formazione tramite kubectl con un job predefinito yaml.
1. aggiorna examples/gpt\$1oss/launch/peft \$1gpt\$1oss\$1120b\$1checkpointless\$1p5.yaml
+ immagine: Un contenitore di Deep Learning. Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di [checkpointless](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) training.
+ [resume.restore\$1config.path=: il percorso per scaricare i pesi dei modelli preaddestrati in formato Nemo nella fase Prerequisiti.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-peft.html#sagemaker-eks-checkpointless-recipes-peft-prereqs)
+ dataset.dataset\$1path=: il percorso del set di dati archiviato nella memoria condivisa
1. Invia il lavoro usando kubectl con peft\$1gpt\$1oss\$1120b\$1checkpointless\$1p5.yaml
```
kubectl apply -f examples/gpt_oss/launch/peft_gpt_oss_120b_checkpointless_p5.yaml
```
Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
gpt-120b-lora-checkpointless-worker-0 0/1 running 0 36s
```
Se lo STATUS è in sospeso o, esegui il seguente comando per ottenere maggiori dettagli ContainerCreating
```
kubectl describe pod
```
Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
# Tutorial - Amazon SageMaker HyperPod Checkpointless Pretraining Llama 3 70b
La seguente sequenza di passaggi è necessaria per eseguire ricette di allenamento senza checkpoint. HyperPod
## Prerequisiti
Prima di iniziare a configurare l’ambiente, assicurati di avere:
+ [Supporto Amazon EKS abilitato in Amazon SageMaker HyperPod](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-prerequisites.html)
+ [Configura l'operatore HyperPod di formazione (v1.2\$1)](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html)
+ Una posizione di archiviazione condivisa. Può essere un FSx file system Amazon o un sistema NFS accessibile dai nodi del cluster.
+ I dati in uno dei seguenti formati:
+ JSON
+ JSONGZ (JSON compresso)
+ ARROW
+ [Scegli una ricetta di formazione supportata senza checkpoint per Llama 70B o GPT-OSS 120B dalla fonte.](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
+ [Scaricate i pesi del modello Hugging](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) [Face e convertiteli nel formato supportato da Nemo.](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemo-2.0/features/hf-integration.html#importing-from-hugging-face)
+ Configurare l’ambiente
## Configurazione dell'ambiente Kubernetes
Per configurare l'ambiente Kubernetes, procedi come segue:
1. Configura l’ambiente virtuale. Assicurati di usare Python maggiore o uguale a 3.10 e inferiore a 3.14.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. [Configura kubectl ed eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
1. [Installa Helm](https://helm.sh/docs/intro/install/)
1. Connettiti al cluster Kubernetes.
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
```
1. Installa le dipendenze utilizzando uno dei metodi seguenti:
1. Metodo 1: metodo SageMaker HyperPod delle ricette:
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
1. Metodo 2: kubectl con metodo job yaml predefinito
```
# install SageMaker HyperPod checkpointless training.
git clone git@github.com:aws/sagemaker-hyperpod-checkpointless-training.git
cd sagemaker-hyperpod-checkpointless-training
```
Ora puoi lanciare la ricetta di allenamento senza checkpointless usando il programma di avvio -style o usando kubectl. NeMo
## Metodo 1: avvia il processo di formazione con il programma di avvio delle ricette
In alternativa, puoi utilizzare le SageMaker HyperPod ricette per inviare il tuo lavoro di formazione. L'uso delle ricette comporta l'aggiornamento di k8s.yaml, config.yaml e l'esecuzione dello script di avvio.
1. Aggiornamento di `launcher_scripts/llama/run_checkpointless_llama3_70b_pretrain.sh`
Un contenitore di Deep Learning. Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di [checkpointless](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) training.
```
#!/bin/bash
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
TRAIN_DIR="${TRAIN_DIR}"
VAL_DIR="${VAL_DIR}"
EXP_DIR="${EXP_DIR}"
LOG_DIR="${LOG_DIR}"
CONTAINER_MOUNT="/data"
CONTAINER="${CONTAINER}"
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=training/llama/checkpointless_llama3_70b_pretrain \
recipes.dataset.dataset_path="${TRAIN_DIR}" \
recipes.exp_manager.exp_dir="${EXP_DIR}" \
recipes.log_dir="${LOG_DIR}" \
recipes.data.global_batch_size=16 \
recipes.data.micro_batch_size=4 \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
git.use_default=false \
cluster=k8s \
cluster_type=k8s \
container="${CONTAINER}" \
+cluster.hostNetwork=true \
+cluster.persistent_volume_claims.0.claimName=fsx-claim \
+cluster.persistent_volume_claims.0.mountPath="${CONTAINER_MOUNT}" \
+recipes.dataset.val_dataset_path="${VAL_DIR}" \
++recipes.callbacks.3.test_fault_config.fault_prob_between_lock=1 \
```
1. Avvio del job di addestramento
```
bash launcher_scripts/llama/run_checkpointless_llama3_70b_pretrain.sh
```
1. Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
llama-3-70b-worker-0 0/1 running 0 36s
```
1. Se lo STATUS è in sospeso o ContainerCreating, esegui il comando seguente per ottenere maggiori dettagli
```
kubectl describe pod
```
1. Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
## Metodo 2: Avvia il processo di formazione con kubectl con yaml predefinito
Un'altra opzione è avviare la formazione tramite kubectl con un job predefinito yaml.
1. Aggiornamento di `examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml`
+ `image`: un container per il Deep Learning. [Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di checkpointless training.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html)
+ `resume.restore_config.path=`[: Il percorso per scaricare i pesi dei modelli preaddestrati in formato Nemo nella fase Prerequisiti.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-finetune.html#sagemaker-eks-checkpointless-recipes-finetune-prereqs)
+ `dataset.dataset_path=`: Il percorso del set di dati archiviato nella memoria condivisa
1. Invia il lavoro usando kubectl con `pretrain_llama3_70b_checkpointless_p5.yaml`
```
kubectl apply -f examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml
```
1. Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
llama3-pretrain-checkpointless-worker-0 0/1 running 0 36s
```
1. Se lo STATUS è in sospeso o ContainerCreating, esegui il seguente comando per ottenere maggiori dettagli
```
kubectl describe pod
```
1. Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
# Tutorial - Amazon SageMaker HyperPod Checkpointless Left-Lora Llama 3 70b
La seguente sequenza di passaggi è necessaria per eseguire ricette di formazione senza checkpoint. HyperPod
## Prerequisiti
Prima di iniziare a configurare l’ambiente, assicurati di avere:
+ [Supporto Amazon EKS abilitato in Amazon SageMaker HyperPod](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-prerequisites.html)
+ [Configura l'operatore HyperPod di formazione (v1.2\$1)](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html)
+ Una posizione di archiviazione condivisa. Può essere un FSx file system Amazon o un sistema NFS accessibile dai nodi del cluster.
+ I dati in uno dei seguenti formati:
+ JSON
+ JSONGZ (JSON compresso)
+ ARROW
+ [Scegli una ricetta di formazione supportata senza checkpoint per Llama 70B o GPT-OSS 120B dalla fonte.](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
+ [Scaricate i pesi del modello Hugging](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) [Face e convertiteli nel formato supportato da Nemo.](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemo-2.0/features/hf-integration.html#importing-from-hugging-face)
+ Configurare l’ambiente
## Configurazione dell'ambiente Kubernetes
Per configurare l'ambiente Kubernetes, procedi come segue:
1. Configura l’ambiente virtuale. Assicurati di usare Python maggiore o uguale a 3.10 e inferiore a 3.14.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. [Configura kubectl ed eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
1. [Installa Helm](https://helm.sh/docs/intro/install/)
1. Connettiti al cluster Kubernetes.
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
```
1. Installa le dipendenze utilizzando uno dei metodi seguenti:
1. Metodo 1: metodo SageMaker HyperPod delle ricette:
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
1. Metodo 2: kubectl con metodo job yaml predefinito
```
# install SageMaker HyperPod checkpointless training.
git clone git@github.com:aws/sagemaker-hyperpod-checkpointless-training.git
cd sagemaker-hyperpod-checkpointless-training
```
Ora puoi lanciare la ricetta di allenamento senza checkpointless usando il programma di avvio -style o usando kubectl. NeMo
## Metodo 1: avvia il processo di formazione con il programma di avvio delle ricette
In alternativa, puoi utilizzare le SageMaker HyperPod ricette per inviare il tuo lavoro di formazione. L'uso delle ricette comporta l'aggiornamento di k8s.yaml, config.yaml e l'esecuzione dello script di avvio.
1. Aggiornamento di `launcher_scripts/llama/run_checkpointless_llama3_70b_lora.sh`
Un contenitore di Deep Learning. Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di [checkpointless](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) training.
```
#!/bin/bash
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
TRAIN_DIR="${TRAIN_DIR}"
VAL_DIR="${VAL_DIR}"
EXP_DIR="${EXP_DIR}"
LOG_DIR="${LOG_DIR}"
CONTAINER_MOUNT="/data"
CONTAINER="${CONTAINER}"
MODEL_NAME_OR_PATH="${MODEL_NAME_OR_PATH}"
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=fine-tuning/llama/checkpointless_llama3_70b_lora \
recipes.dataset.dataset_path="${TRAIN_DIR}" \
recipes.exp_manager.exp_dir="${EXP_DIR}" \
recipes.log_dir="${LOG_DIR}" \
recipes.resume.restore_config.path="${MODEL_NAME_OR_PATH}" \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
git.use_default=false \
cluster=k8s \
cluster_type=k8s \
container="${CONTAINER}" \
+cluster.hostNetwork=true \
+cluster.persistent_volume_claims.0.claimName=fsx-claim \
+cluster.persistent_volume_claims.0.mountPath="${CONTAINER_MOUNT}" \
+recipes.dataset.val_dataset_path="${VAL_DIR}" \
++recipes.callbacks.3.test_fault_config.fault_prob_between_lock=1 \
```
1. Avvio del job di addestramento
```
bash launcher_scripts/llama/run_checkpointless_llama3_70b_lora.sh
```
1. Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
llama-3-70b-worker-0 0/1 running 0 36s
```
1. Se lo STATUS è in sospeso o ContainerCreating, esegui il comando seguente per ottenere maggiori dettagli
```
kubectl describe pod
```
1. Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
## Metodo 2: Avvia il processo di formazione con kubectl con yaml predefinito
Un'altra opzione è avviare la formazione tramite kubectl con un job predefinito yaml.
1. Aggiornamento di `examples/llama3/launch/peft_llama3_70b_checkpointless_p5.yaml`
+ `image`: un container per il Deep Learning. [Per trovare la versione più recente del contenitore di formazione checkpointless, consulta le note sulla versione di checkpointless training.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html)
+ `resume.restore_config.path=`[: Il percorso per scaricare i pesi dei modelli preaddestrati in formato Nemo nella fase Prerequisiti.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-recipes-finetune.html#sagemaker-eks-checkpointless-recipes-finetune-prereqs)
+ `dataset.dataset_path=`: Il percorso del set di dati archiviato nella memoria condivisa
1. Invia il lavoro usando kubectl con `peft_llama3_70b_checkpointless_p5.yaml`
```
kubectl apply -f examples/llama3/launch/peft_llama3_70b_checkpointless_p5.yaml
```
1. Dopo aver inviato il job di addestramento, puoi utilizzare il comando seguente per verificare se l’invio è riuscito.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
llama3-70b-lora-checkpointless-worker-0 0/1 running 0 36s
```
1. Se lo STATUS è in sospeso o ContainerCreating, esegui il seguente comando per ottenere maggiori dettagli
```
kubectl describe pod
```
1. Quando lo STATUS del processo diventa Running, puoi esaminare il log utilizzando il comando seguente.
```
kubectl logs
```
Lo STATUS diventerà Completato quando esegui kubectl get pods
# Tutorial - Amazon SageMaker HyperPod Checkpointless, preaddestramento o messa a punto di modelli personalizzati
La seguente sequenza di passaggi è necessaria per eseguire un addestramento senza checkpoint con il modello personalizzato acceso. HyperPod
## Prerequisiti
Prima di iniziare a configurare l’ambiente, assicurati di avere:
+ [Supporto Amazon EKS abilitato in Amazon SageMaker HyperPod](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-prerequisites.html)
+ [Configura l'operatore HyperPod di formazione (v1.2\$1)](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html)
+ Una posizione di archiviazione condivisa. Può essere un FSx file system Amazon o un sistema NFS accessibile dai nodi del cluster.
+ I dati in uno dei seguenti formati:
+ JSON
+ JSONGZ (JSON compresso)
+ ARROW
+ [Scarica i pesi del modello Hugging Face](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-checkpointless-release-notes.html) [e convertili nel formato supportato da Nemo.](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemo-2.0/features/hf-integration.html#importing-from-hugging-face)
+ Configurare l’ambiente
## Configurazione dell'ambiente Kubernetes
Per configurare l'ambiente Kubernetes, procedi come segue:
1. Configura l’ambiente virtuale. Assicurati di usare Python maggiore o uguale a 3.10 e inferiore a 3.14.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. [Configura kubectl ed eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
1. Connettiti al cluster Kubernetes.
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
```
1. Installare le dipendenze
```
# install SageMaker HyperPod checkpointless training.
git clone git@github.com:aws/sagemaker-hyperpod-checkpointless-training.git
cd sagemaker-hyperpod-checkpointless-training
```
## Istruzioni di modifica dell'allenamento Checkpointless
Per adottare in modo incrementale la formazione senza checkpoint per i modelli personalizzati, segui la guida all'integrazione (qui utilizziamo il pretraining di Llama 3 70b come esempio), che prevede:
+ Creazione rapida di comunicatori
+ Dataloader mappato in memoria (MMAP)
+ Ripristino in corso e senza checkpoint
### Componente 1: creazione rapida di comunicatori
Questo per ottimizzare i tempi necessari per stabilire connessioni tra i lavoratori. Non sono necessarie modifiche al codice e richiede solo l'impostazione delle variabili env
```
# Enable Rootless features
export HPCT_USE_ROOTLESS=1 && \
sysctl -w net.ipv4.ip_local_port_range="20000 65535" && \
hyperpodrun --nproc_per_node=8 \
...
--inprocess-restart \
...
```
La modifica completa può essere trovata nel file [llama3 70 pretrain](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml) launch job config.
### Componente 2: Dataloader mappato in memoria (MMAP)
Cache MMAP per archiviare campioni di dati precaricati e consentire l'avvio immediato della formazione senza dover attendere la preelaborazione dei dati. Richiede modifiche minime al codice da adottare inserendo il dataloader esistente.
```
data_module = MMAPDataModule(
data_module=base_data_module,
mmap_config=CacheResumeMMAPConfig(cache_dir=…)
)
```
### Componenti 3 e 4: ripristino in corso e senza checkpoint
Ciò consente il ripristino in caso di errore senza riavviare i processi di addestramento o il caricamento dai checkpoint. Sono necessarie ulteriori modifiche al codice (aggiornamento della configurazione di strategia e formazione, wrap existing main)
```
@HPWrapper(
health_check=CudaHealthCheck(),
hp_api_factory=HPAgentK8sAPIFactory(),
abort_timeout=60.0,
...)
def run_main(
cfg,
caller: Optional[HPCallWrapper] = None):
...
CheckpointlessMegatronStrategy(
**self.cfg.strategy,
ddp=self.ddp,
)
```
[La modifica completa è disponibile nello [script di immissione pretrain di llama3 70](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/llama3_70b_pretrain_checkpointless.py) e la corrispondente modifica alla configurazione di allenamento è disponibile nella configurazione di addestramento di llama3 70b.](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/config/llama3_70b_peft_checkpointless.yaml)
### Avvia la formazione
Ora puoi avviare l'allenamento senza checkpoint usando kubectl.
```
kubectl apply -f your_job_config.yaml
```
# HyperPod funzionalità di formazione senza checkpointless
Consulta le pagine seguenti per conoscere le funzionalità di formazione della formazione senza checkpointless.
**Topics**
+ [Archivi di formazione SageMaker HyperPod senza checkpoint di Amazon](#sagemaker-eks-checkpointless-repositories)
+ [Miglioramenti all'inizializzazione della comunicazione collettiva](sagemaker-eks-checkpointless-features-communication.md)
+ [Dataloader mappato in memoria](sagemaker-eks-checkpointless-features-mmap.md)
+ [Recupero durante il processo e formazione senza checkpoint](sagemaker-eks-checkpointless-in-process-recovery.md)
## Archivi di formazione SageMaker HyperPod senza checkpoint di Amazon
[ HyperPod checkpointless training](https://github.com/aws/sagemaker-hyperpod-checkpointless-training#) accelera il ripristino dai guasti dei cluster in ambienti di formazione distribuiti su larga scala attraverso ottimizzazioni a livello di framework. Queste ottimizzazioni vengono fornite tramite un'immagine del contenitore di base che include miglioramenti avanzati dell'inizializzazione NCCL, ottimizzazioni del caricamento dei dati e componenti di ripristino in corso e senza checkpoint. Il pacchetto di formazione HyperPod checkpointless si basa su queste basi.
La formazione Checkpointless è abilitata tramite tre percorsi di ottimizzazione eseguiti in sinergia:
+ **Miglioramenti all'inizializzazione della comunicazione (NCCL e Gloo)**: elimina gli ostacoli alla comunicazione decentralizzando le informazioni di rango tra pari e ring (riquadro rosso in basso).
+ **Ottimizzazioni del caricamento dei dati**: riduci il tempo necessario per fornire il primo batch di dati durante le operazioni di riavvio (riquadri arancioni sotto).
+ **Riduzione del sovraccarico di riavvio del programma**: riduci al minimo i costi di riavvio e abilita il rifornimento senza checkpoint attraverso il ripristino del processo su nodi integri (riquadri blu e verdi di seguito).
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimization-tracks.png)
# Miglioramenti all'inizializzazione della comunicazione collettiva
NCCL e Gloo sono librerie di comunicazione fondamentali che consentono operazioni collettive (come all-reduce e broadcast) attraverso processi di formazione distribuiti. Tuttavia, l'inizializzazione tradizionale di NCCL e Gloo può creare colli di bottiglia durante il ripristino dei guasti.
Il processo di ripristino standard richiede che tutti i processi si connettano a un sistema centralizzato TCPStore e si coordinino tramite un processo root, il che comporta un oneroso sovraccarico che diventa particolarmente problematico durante i riavvii. Questo design centralizzato crea tre problemi critici: sovraccarico di coordinamento dovuto alle TCPStore connessioni obbligatorie, ritardi di ripristino poiché ogni riavvio deve ripetere l'intera sequenza di inizializzazione e un singolo punto di errore nel processo principale stesso. Ciò impone procedure di coordinamento costose e centralizzate ogni volta che la formazione viene inizializzata o riavviata.
HyperPod la formazione senza checkpointless elimina questi ostacoli di coordinamento, permettendo un recupero più rapido dai guasti grazie a un'inizializzazione «senza radici» e «...» TCPStoreless
## configurazioni rootless
Per abilitare Rootless, è sufficiente esporre le seguenti variabili di ambiente.
```
export HPCT_USE_ROOTLESS=1 && \
sysctl -w net.ipv4.ip_local_port_range="20000 65535" && \
```
HPCT\$1USE\$1ROOTLESS: 0 o 1. Si usa per accendere e spegnere rootless
sysctl -w net.ipv4.ip\$1local\$1port\$1range="20000 65535": imposta l'intervallo delle porte di sistema
[Vedi l'esempio per abilitare Rootless](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml#L111-L113).
## Rootless
HyperPod checkpointless training offre nuovi metodi di inizializzazione, Rootless e, per i gruppi di processi NCCL e TCPStoreless Gloo.
L'implementazione di queste ottimizzazioni comporta la modifica di NCCL, Gloo e: PyTorch
+ Estensione della libreria di terze parti APIs per abilitare le ottimizzazioni Rootless e Storeless NCCL e Gloo mantenendo al contempo la compatibilità con le versioni precedenti
+ Aggiornamento dei backend dei gruppi di processi per utilizzare in modo condizionale percorsi ottimizzati e gestire i problemi di ripristino durante il processo
+ Evitando costose TCPStore creazioni a livello PyTorch distribuito mantenendo al contempo modelli di indirizzi simmetrici attraverso contatori di gruppo globali
Il grafico seguente mostra l'architettura delle librerie di formazione distribuite e le modifiche apportate alla formazione senza checkpoint.
![\[Il grafico seguente mostra l'architettura delle librerie di formazione distribuite e le modifiche apportate alla formazione senza checkpointless.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-libraries.png)
### NCCL e Gloo
Si tratta di pacchetti indipendenti che eseguono le funzionalità principali delle comunicazioni collettive. Forniscono chiavi APIs, come ncclCommInit Rank, per inizializzare le reti di comunicazione, gestire le risorse sottostanti ed eseguire comunicazioni collettive. Dopo aver apportato modifiche personalizzate a NCCL e Gloo, Rootless e Storeless ottimizzano (ad esempio, saltando la connessione a) l'inizializzazione della rete di comunicazione. TCPStore È possibile passare dall'utilizzo dei percorsi di codice originali ai percorsi di codice ottimizzati in modo flessibile.
### PyTorch backend del gruppo di processi
I backend del gruppo di processi, in particolare ProcessGroup NCCL e ProcessGroupGloo, lo implementano ProcessGroup APIs richiamando le APIs librerie sottostanti corrispondenti. Poiché estendiamo le librerie di terze parti APIs, dobbiamo richiamarle correttamente e modificare il percorso del codice in base alle configurazioni dei clienti.
Oltre all'ottimizzazione dei percorsi di codice, modifichiamo anche il backend del gruppo di processi per supportare il ripristino durante il processo.
# Dataloader mappato in memoria
Un altro sovraccarico di riavvio deriva dal caricamento dei dati: il cluster di addestramento rimane inattivo mentre il dataloader si inizializza, scarica i dati dai file system remoti e li elabora in batch.
Per risolvere questo problema, introduciamo il Memory Mapped DataLoader (MMAP) Dataloader, che memorizza nella cache i batch preimpostati nella memoria persistente, assicurando che rimangano disponibili anche dopo un riavvio indotto da un errore. Questo approccio elimina i tempi di configurazione del dataloader e consente di riprendere immediatamente l'addestramento utilizzando batch memorizzati nella cache, mentre il dataloader reinizializza e recupera contemporaneamente i dati successivi in background. La cache dei dati si trova su ogni livello che richiede dati di addestramento e mantiene due tipi di batch: i batch consumati di recente e utilizzati per l'addestramento e i batch precaricati pronti per l'uso immediato.
![\[Questa immagine illustra il Dataloader MMAP, le cache e i batch utilizzati.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-mmap-dataloader.png)
Il dataloader MMAP offre due funzionalità seguenti:
+ **Prefetching dei dati**: recupera e memorizza in modo proattivo i dati generati dal dataloader
+ **Memorizzazione nella cache persistente**: archivia i batch consumati e quelli precaricati in un file system temporaneo che sopravvive al riavvio del processo
Utilizzando la cache, il processo di formazione trarrà vantaggio da:
+ **Impronta di memoria ridotta**: sfrutta la mappatura della memoria I/O per mantenere una singola copia condivisa dei dati nella memoria della CPU host, eliminando le copie ridondanti tra i processi GPU (ad esempio, riduce da 8 copie a 1 su un'istanza p5 con 8) GPUs
+ **Ripristino più rapido**: riduce il tempo medio di riavvio (MTTR) grazie alla possibilità di riprendere immediatamente la formazione dai batch memorizzati nella cache, eliminando così l'attesa per la reinizializzazione del dataloader e la prima generazione del batch
## Configurazioni MMAP
Per utilizzare MMAP, è sufficiente inserire il modulo dati originale in `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`: I parametri di MMAP Dataloader controllano la posizione della directory della cache, i limiti di dimensione e la delega per il recupero dei dati. Per impostazione predefinita, solo il livello TP 0 per nodo recupera i dati dall'origine, mentre gli altri ranghi dello stesso gruppo di replica li leggono dalla cache condivisa, eliminando i trasferimenti ridondanti.
`MMAPDataModule`: racchiude il modulo di dati originale e restituisce il dataloader mmap sia per l'addestramento che per la convalida.
[Vedi l'esempio per abilitare MMAP.](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune_checkpointless.py#L101-L109)
## Guida di riferimento alle 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)
```
Classe di configurazione per la funzionalità del dataloader cache-resume memory-mapped (MMAP) durante la formazione senza checkpoint. HyperPod
Questa configurazione consente un caricamento efficiente dei dati con funzionalità di caching e prefetching, permettendo di riprendere rapidamente l'addestramento dopo i guasti mantenendo i batch di dati memorizzati nella cache in file mappati in memoria.
**Parametri**
+ **cache\$1dir** (str, opzionale) — Percorso della directory per l'archiviazione dei batch di dati memorizzati nella cache. Predefinito: «/\$1cache» dev/shm/pdl
+ **prefetch\$1length** (int, opzionale) — Numero di batch da prerecuperare durante l'allenamento. Impostazione predefinita: 10
+ **val\$1prefetch\$1length** (int, opzionale) — Numero di batch da prerecuperare in anticipo durante la convalida. Impostazione predefinita: 10
+ **lookback\$1length** (int, opzionale) — Numero di batch utilizzati in precedenza da conservare nella cache per un potenziale riutilizzo. Impostazione predefinita: 2
+ **checkpoint\$1frequency (int, opzionale) — Frequenza delle** fasi di checkpoint del modello. Utilizzato per l'ottimizzazione delle prestazioni della cache. Impostazione predefinita: nessuna
+ **model\$1parallel\$1group (oggetto, opzionale) — Gruppo** di processi per il parallelismo dei modelli. Se Nessuno, verrà creato automaticamente. Impostazione predefinita: nessuna
+ **enable\$1batch\$1encryption** (bool, opzionale) — Indica se abilitare la crittografia per i dati batch memorizzati nella cache. Impostazione predefinita: False
**Metodi**
```
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)
```
Crea e restituisce un'istanza di dataloader MMAP configurata.
**Parametri**
+ **dataloader\$1init\$1callable (Callable**) — Funzione per inizializzare il dataloader sottostante
+ **parallel\$1state\$1util (object) — Utilità** per la gestione dello stato parallelo tra i processi
+ **step** (int) — La fase relativa ai dati da cui riprendere durante l'allenamento
+ **is\$1data\$1loading\$1rank (Callable) — Funzione che restituisce True se il rank** corrente deve caricare i dati
+ **create\$1model\$1parallel\$1group\$1callable (Callable**) — Funzione per creare un gruppo di processi parallelo modello
+ name (str, opzionale) — **Identificatore del nome** per il dataloader. Predefinito: «Train»
+ **is\$1val** (bool, opzionale) — Se si tratta di un dataloader di convalida. Impostazione predefinita: False
+ **cached\$1len** (int, opzionale) — Lunghezza dei dati memorizzati nella cache se si riprende dalla cache esistente. Impostazione predefinita: 0
Restituisce `CacheResumePrefetchedDataLoader` o: istanza del dataloader MMAP configurata `CacheResumeReadDataLoader`
Aumenta `ValueError` se il parametro step è. `None`
**Esempio**
```
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"
)
```
**Note**
+ La directory della cache dovrebbe avere spazio sufficiente e I/O prestazioni veloci (ad esempio, /dev/shm per l'archiviazione in memoria).
+ L'impostazione `checkpoint_frequency` migliora le prestazioni della cache allineando la gestione della cache con il checkpointing del modello
+ Per i dataloaders di convalida (`is_val=True`), il passaggio viene reimpostato su 0 e l'avvio a freddo viene forzato
+ Vengono utilizzate diverse implementazioni del dataloader a seconda che il rango corrente sia responsabile del caricamento dei dati
### MMAPDataModulo
```
class hyperpod_checkpointless_training.dataloader.mmap_data_module.MMAPDataModule(
data_module,
mmap_config,
parallel_state_util=MegatronParallelStateUtil(),
is_data_loading_rank=None)
```
Un DataModule wrapper PyTorch Lightning che applica funzionalità di caricamento dei dati mappate in memoria (MMAP) a quelle esistenti per un addestramento senza checkpoint. DataModules
Questa classe integra un PyTorch Lightning esistente e lo migliora con la funzionalità MMAP, che consente una memorizzazione efficiente dei dati nella cache DataModule e un ripristino rapido in caso di errori di formazione. Mantiene la compatibilità con l'interfaccia originale DataModule aggiungendo funzionalità di formazione senza checkpoint.
Parameters
data\$1module (pl. LightningDataModule)
Il sottostante DataModule da avvolgere (ad esempio, LLMData Module)
mmap\$1config () MMAPConfig
L'oggetto di configurazione MMAP che definisce il comportamento e i parametri della memorizzazione nella cache
`parallel_state_util`(MegatronParallelStateUtil, opzionale)
Utilità per la gestione dello stato parallelo tra processi distribuiti. Impostazione predefinita: MegatronParallelStateUtil ()
`is_data_loading_rank`(Richiamabile, opzionale)
Funzione che restituisce True se il rango corrente deve caricare dati. Se Nessuno, il valore predefinito è parallel\$1state\$1util.is\$1tp\$10. Impostazione predefinita: nessuna
**Attributes**
`global_step` (int)
Fase di formazione globale attuale, utilizzata per riprendere dai checkpoint
`cached_train_dl_len` (int)
Lunghezza memorizzata nella cache del dataloader di addestramento
`cached_val_dl_len` (int)
Lunghezza memorizzata nella cache del dataloader di convalida
**Metodi**
```
setup(stage=None)
```
Imposta il modulo di dati sottostante per la fase di formazione specificata.
`stage`(str, opzionale)
Fase dell'allenamento («adattamento», «convalida», «test» o «previsione»). Impostazione predefinita: nessuna
```
train_dataloader()
```
Crea l'allenamento DataLoader con MMAP wrapping.
*Restituisce: DataLoader — Addestramento* basato su MMAP con funzionalità di caching e prefetching DataLoader
```
val_dataloader()
```
Crea la convalida con MMAP wrapping. DataLoader
*Restituisce:* DataLoader — Validazione avvolta in MMAP con funzionalità di memorizzazione nella cache DataLoader
```
test_dataloader()
```
Crea il test DataLoader se il modulo di dati sottostante lo supporta.
*Restituisce:* DataLoader o Nessuno: esegue il test DataLoader dal modulo di dati sottostante o Nessuno se non è supportato
```
predict_dataloader()
```
Crea la previsione DataLoader se il modulo di dati sottostante la supporta.
*Restituisce:* DataLoader o Nessuno: prevedi DataLoader dal modulo di dati sottostante o Nessuno se non è supportato
```
load_checkpoint(checkpoint)
```
Carica le informazioni sul checkpoint per riprendere l'allenamento da una fase specifica.
checkpoint (dict)
dizionario Checkpoint contenente la chiave 'global\$1step'
```
get_underlying_data_module()
```
Ottieni il modulo di dati racchiuso sottostante.
*Restituisce:* pl. LightningDataModule — Il modulo dati originale che è stato confezionato
```
state_dict()
```
Ottieni il dizionario di stato del MMAP DataModule per il checkpoint.
*Restituisce:* dict — Dizionario contenente le lunghezze del dataloader memorizzate nella cache
```
load_state_dict(state_dict)
```
Carica il dizionario di stato per ripristinare lo stato MMAP. DataModule
`state_dict`(dict)
Dizionario di stato da caricare
**Proprietà**
```
data_sampler
```
Esporre il campionatore di dati del modulo di dati sottostante al framework. NeMo
*Restituisce:* object or None: il campionatore di dati del modulo di dati sottostante
**Esempio**
```
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)
```
**Note**
+ Il wrapper delega la maggior parte dell'accesso degli attributi al modulo di dati sottostante utilizzando \$1\$1getattr\$1\$1
+ Solo i ranghi di caricamento dei dati inizializzano e utilizzano effettivamente il modulo di dati sottostante; gli altri ranghi utilizzano dataloader falsi
+ Le lunghezze dei dataloader memorizzati nella cache vengono mantenute per ottimizzare le prestazioni durante la ripresa dell'allenamento
# Recupero durante il processo e formazione senza checkpoint
HyperPod la formazione senza checkpointless utilizza la ridondanza dei modelli per consentire un addestramento tollerante ai guasti. Il principio fondamentale è che gli stati del modello e dell'ottimizzatore vengono completamente replicati su più gruppi di nodi, con aggiornamenti di peso e modifiche dello stato dell'ottimizzatore replicati in modo sincrono all'interno di ciascun gruppo. Quando si verifica un errore, le repliche integre completano le fasi di ottimizzazione e trasmettono gli stati aggiornati alle repliche in fase di ripristino. model/optimizer
Questo approccio basato sulla ridondanza del modello consente diversi meccanismi di gestione dei guasti:
+ **Ripristino durante il processo:** i processi rimangono attivi nonostante i guasti, mantenendo tutti gli stati del modello e dell'ottimizzatore nella memoria della GPU con i valori più recenti
+ **Gestione agevole delle interruzioni: aborti** controllati e pulizia delle risorse per le operazioni interessate
+ Riesecuzione **del blocco di codice: riesecuzione** solo dei segmenti di codice interessati all'interno di un blocco di codice rieseguibile (RCB)
+ **Recupero senza punti di controllo senza perdita dei progressi di allenamento:** poiché i processi persistono e gli stati rimangono in memoria, nessun progresso dell'allenamento viene perso; quando si verifica un errore, l'allenamento riprende dalla fase precedente, anziché riprendere dall'ultimo checkpoint salvato
**Configurazioni senza checkpoint**
Ecco il frammento principale della formazione senza checkpointless.
```
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`: Tutti i ranghi aspetteranno le informazioni sulla classifica dall'infrastruttura. HyperpodTrainingOperator
+ `HPWrapper`: wrapper di funzioni Python che abilita le funzionalità di riavvio per un blocco di codice rieseguibile (RCB). L'implementazione utilizza un gestore di contesto anziché un decoratore Python perché i decoratori non possono determinare il numero di elementi da RCBs monitorare in fase di esecuzione.
+ `CudaHealthCheck`: Assicura che il contesto CUDA per il processo corrente sia integro mediante la sincronizzazione con la GPU. Utilizza il dispositivo specificato dalla variabile di ambiente LOCAL\$1RANK o utilizza come impostazione predefinita il dispositivo CUDA del thread principale se LOCAL\$1RANK non è impostato.
+ `HPAgentK8sAPIFactory`: Questa API consente la formazione senza checkpoint per interrogare lo stato di addestramento di altri pod nel cluster di formazione Kubernetes. Fornisce inoltre una barriera a livello di infrastruttura che garantisce che tutti i ranghi completino con successo le operazioni di interruzione e riavvio prima di procedere.
+ `CheckpointManager`: Gestisce i checkpoint in memoria e il ripristino per una tolleranza agli errori senza checkpoint. peer-to-peer Ha le seguenti responsabilità principali:
+ **Gestione dei checkpoint in memoria**: salva e gestisce i checkpoint NeMo del modello in memoria per un ripristino rapido senza disco I/O durante gli scenari di ripristino senza checkpoint.
+ Convalida **della fattibilità del ripristino: determina se è possibile il ripristino senza checkpoint convalidando** la coerenza globale dei passaggi, lo stato del rango e l'integrità dello stato del modello.
+ **Peer-to-Peer Orchestrazione del ripristino: coordina il trasferimento dei** checkpoint tra i ranghi sani e quelli danneggiati utilizzando la comunicazione distribuita per un ripristino rapido.
+ **Gestione dello stato RNG**: conserva e ripristina gli stati dei generatori di numeri casuali su Python e Megatron per il NumPy ripristino PyTorch deterministico.
+ **[Opzionale] Checkpoint Offload: trasferisci il checkpoint** di memoria sulla CPU se la GPU non ha una capacità di memoria sufficiente.
+ `PEFTCheckpointManager`: Si estende mantenendo i pesi del modello base `CheckpointManager` per la regolazione fine del PEFT.
+ `CheckpointlessAbortManager`: Gestisce le operazioni di interruzione in un thread in background quando si verifica un errore. Per impostazione predefinita, interrompe TransformerEngine, Checkpointing e. TorchDistributed DataLoader Gli utenti possono registrare gestori di aborti personalizzati in base alle esigenze. Una volta completata l'interruzione, tutte le comunicazioni devono cessare e tutti i processi e i thread devono terminare per evitare perdite di risorse.
+ `CheckpointlessFinalizeCleanup`: gestisce le operazioni di pulizia finale nel thread principale per i componenti che non possono essere interrotti o ripuliti in modo sicuro nel thread in background.
+ `CheckpointlessMegatronStrategy`: Eredita dalla forma di Nemo`MegatronStrategy`. Nota che l'addestramento senza checkpoint richiede almeno 2 partecipanti `num_distributed_optimizer_instances` per consentire la replica dell'ottimizzatore. La strategia si occupa anche della registrazione degli attributi essenziali e dell'inizializzazione dei gruppi di processi, ad esempio rootless.
+ `CheckpointlessCallback`: Lightning callback che integra l' NeMo allenamento con il sistema di tolleranza ai guasti di checkpointless training. Ha le seguenti responsabilità principali:
+ **Gestione del ciclo di vita delle fasi di allenamento**: tiene traccia dei progressi dell'allenamento e si coordina ParameterUpdateLock per enable/disable un recupero senza problemi in base allo stato dell'allenamento (prima fase e fasi successive).
+ **Checkpoint State Coordination**: gestisce il salvataggio/ripristino dei checkpoint del modello base PEFT in memoria.
+ `CheckpointlessCompatibleConnector`: Un PTL `CheckpointConnector` che tenta di precaricare il file di checkpoint in memoria, con il percorso di origine determinato in base a questa priorità:
+ prova checkpointless recovery
+ se checkpointless restituisce None, torna a parent.resume\$1start ()
Guarda l'esempio per aggiungere funzionalità di formazione senza [checkpointless ai codici.](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune.py)
**Concetti**
Questa sezione introduce concetti di formazione senza checkpoint. La formazione Checkpointless su Amazon SageMaker HyperPod supporta il ripristino in corso. Questa interfaccia API segue un formato simile a quello di. NVRx APIs
**Concetto: Re-Executable Code Block (RCB)**
Quando si verifica un errore, i processi sani rimangono attivi, ma una parte del codice deve essere rieseguita per ripristinare gli stati di addestramento e gli stack python. Un Re-Executable Code Block (RCB) è un segmento di codice specifico che viene eseguito nuovamente durante il ripristino in caso di errore. Nell'esempio seguente, l'RCB comprende l'intero script di addestramento (ovvero, tutto ciò che è contenuto in main ()), il che significa che ogni ripristino in caso di errore riavvia lo script di addestramento preservando il modello in memoria e gli stati dell'ottimizzatore.
**Concetto: controllo dei guasti**
Un modulo di controllo dei guasti riceve notifiche quando si verificano guasti durante un addestramento senza checkpoint. Questo controller di guasto include i seguenti componenti:
+ **Modulo di rilevamento dei guasti:** riceve notifiche di guasti dell'infrastruttura
+ **Definizione RCB APIs:** consente agli utenti di definire il blocco di codice rieseguibile (RCB) nel proprio codice
+ **Modulo di riavvio:** termina l'RCB, ripulisce le risorse e riavvia l'RCB
![\[Questa immagine illustra come un modulo di controllo dei guasti riceve notifiche quando si verifica un errore durante un addestramento senza checkpoint.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-fault-controller-module.png)
**Concetto: ridondanza del modello**
L'addestramento su modelli di grandi dimensioni richiede in genere una dimensione parallela dei dati sufficientemente grande per addestrare i modelli in modo efficiente. Nel tradizionale parallelismo dei dati come PyTorch DDP e Horovod, il modello è completamente replicato. Le tecniche più avanzate di parallelismo dei dati condivisi come DeepSpeed Zero Optimizer e FSDP supportano anche la modalità di sharding ibrida, che consente di suddividere gli stati all'interno del gruppo di sharding e di replicarli completamente tra i gruppi di replica. model/optimizer NeMo ha anche questa funzione di sharding ibrido tramite un argomento num\$1distributed\$1optimizer\$1instances, che consente la ridondanza.
Tuttavia, l'aggiunta della ridondanza indica che il modello non sarà completamente suddiviso in tutto il cluster, con conseguente maggiore utilizzo della memoria del dispositivo. La quantità di memoria ridondante varierà a seconda delle specifiche tecniche di sharding del modello implementate dall'utente. I pesi, i gradienti e la memoria di attivazione del modello a bassa precisione non ne risentiranno, poiché vengono suddivisi tramite il parallelismo del modello. Il modello master ad alta precisione e gli stati dell'ottimizzatore ne risentiranno. weights/gradients L'aggiunta di una replica ridondante del modello aumenta l'utilizzo della memoria del dispositivo all'incirca dell'equivalente delle dimensioni di un checkpoint DCP.
Lo sharding ibrido suddivide i collettivi di tutti i gruppi DP in collettivi relativamente più piccoli. In precedenza c'era una riduzione della dispersione e un raggruppamento universale tra l'intero gruppo DP. Dopo lo sharding ibrido, il reduce-scatter viene eseguito solo all'interno di ogni replica del modello e verrà applicata una riduzione totale tra i gruppi di repliche dei modelli. L'all-collect funziona anche all'interno di ogni replica del modello. Di conseguenza, l'intero volume di comunicazioni rimane pressoché invariato, ma i collettivi utilizzano gruppi più piccoli, quindi ci aspettiamo una latenza migliore.
**Concetto: tipi di errore e riavvio**
La tabella seguente riporta i diversi tipi di errore e i meccanismi di ripristino associati. Checkpointless training tenta innanzitutto il ripristino in caso di errore tramite un ripristino in corso, seguito da un riavvio a livello di processo. Si ritorna al riavvio a livello di processo solo in caso di guasto catastrofico (ad esempio, guasto di più nodi contemporaneamente).
| Tipo di errore | Causa | Tipo di ripristino | Meccanismo di ripristino |
| --- | --- | --- | --- |
| Guasto durante il processo | Errori a livello di codice, eccezioni | Ripristino in corso (IPR) | Riesegui RCB all'interno del processo esistente; i processi sani rimangono attivi |
| Errore di riavvio del processo | Contesto CUDA danneggiato, processo interrotto | Riavvio a livello di processo (PLR) | SageMaker HyperPod l'operatore addetto alla formazione riavvia i processi; salta il riavvio del pod K8s |
| Errore di sostituzione del nodo | Guasto node/GPU hardware permanente | Job Level Restart (JLR) | Sostituisci il nodo fallito; riavvia l'intero processo di formazione |
**Concetto: protezione Atomic Lock per Optimizer Step**
L'esecuzione del modello è suddivisa in tre fasi: propagazione in avanti, propagazione all'indietro e fase di ottimizzazione. Il comportamento di ripristino varia in base alla tempistica dell'errore:
+ **Propagazione avanti/indietro:** torna all'inizio della fase di addestramento corrente e trasmetti gli stati del modello ai nodi sostitutivi
+ **Fase di ottimizzazione:** consenti alle repliche sane di completare la fase di blocco della protezione, quindi trasmetti gli stati aggiornati del modello ai nodi sostitutivi
Questa strategia garantisce che gli aggiornamenti completati dell'ottimizzatore non vengano mai scartati, contribuendo a ridurre i tempi di ripristino dei guasti.
![\[Questa immagine illustra come viene gestito l'errore a seconda che si verifichi prima o dopo l'errore.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimizer.png)
## Diagramma del flusso di allenamento Checkpointless
![\[Questo diagramma illustra il flusso di allenamento senza checkpoint.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-flow.png)
I passaggi seguenti descrivono il processo di rilevamento degli errori e di ripristino senza checkpoint:
1. Inizia il ciclo di formazione
1. Si verifica un errore
1. Valuta la fattibilità di un curriculum senza controlli
1. Verifica se è possibile eseguire un curriculum senza checkpoint
+ Se possibile, prova a riprendere senza checkpointless
+ Se la ripresa fallisce, torna al caricamento del checkpoint dallo storage
+ Se la ripresa ha esito positivo, l'allenamento continua dallo stato di ripristino
+ Se non è possibile, ricorri al checkpoint di caricamento dal magazzino
1. Pulisci le risorse: interrompi tutti i gruppi di processi e i backend e libera le risorse in preparazione al riavvio.
1. Riprendi il ciclo di allenamento: inizia un nuovo ciclo di allenamento e il processo torna alla fase 1.
## Guida di riferimento alle API
### wait\$1rank
```
hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()
```
Attende e recupera le informazioni sulla classificazione da HyperPod, quindi aggiorna l'ambiente di processo corrente con variabili di addestramento distribuite.
Questa funzione ottiene l'assegnazione del grado e le variabili di ambiente corrette per l'addestramento distribuito. Garantisce che ogni processo ottenga la configurazione appropriata per il suo ruolo nel processo di formazione distribuito.
**Parametri**
Nessuno
**Valori restituiti**
**Nessuno**
**Comportamento**
+ **Controllo del processo**: salta l'esecuzione se viene chiamato da un sottoprocesso (viene eseguito solo in) MainProcess
+ **Recupero dell'ambiente: recupera le variabili** correnti `RANK` e da quelle di ambiente `WORLD_SIZE`
+ **HyperPod Comunicazione**: chiamate `hyperpod_wait_rank_info()` da cui recuperare informazioni sulla classifica HyperPod
+ **Aggiornamento dell'ambiente**: aggiorna l'ambiente di processo corrente con le variabili di ambiente specifiche del lavoratore ricevute da HyperPod
**Variabili di ambiente**
La funzione legge le seguenti variabili di ambiente:
+ **RANK** (*int*) — Classificazione attuale del processo (impostazione predefinita: -1 se non è impostata)
+ **WORLD\$1SIZE** (*int*) — Numero totale di processi nel processo distribuito (predefinito: 0 se non è impostato)
**Aumenta**
+ **AssertionError**— Se la risposta di non HyperPod è nel formato previsto o se mancano i campi obbligatori
**Esempio**
```
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')
```
**Note**
+ Viene eseguito solo nel processo principale; le chiamate ai sottoprocessi vengono saltate automaticamente
+ La funzione si blocca finché non HyperPod fornisce le informazioni sulla classificazione
### 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)
```
*Wrapper di funzioni Python che abilita le funzionalità di riavvio per un Re-Executable Code Block (RCB) durante un addestramento senza checkpoint. HyperPod *
*Questo wrapper offre funzionalità di tolleranza agli errori e ripristino automatico monitorando l'esecuzione della formazione e coordinando i riavvii tra i processi distribuiti in caso di errori. Utilizza un approccio di gestione del contesto anziché un decoratore per mantenere le risorse globali durante tutto il ciclo di vita della formazione.*
**Parametri**
+ **abort** (Abort, *opzionale*): *interrompe* l'esecuzione in modo asincrono quando vengono rilevati errori. Impostazione predefinita: `Compose(HPAbortTorchDistributed())`
+ **finalize (Finalize**, *opzionale*) — Gestore di *finalizzazione* Rank-Local eseguito durante il riavvio. Impostazione predefinita: `None`
+ **health\$1check (*HealthCheck*, *opzionale*) — Controllo dello** stato di salute di Rank-local eseguito durante il riavvio. Impostazione predefinita: `None`
+ **hp\$1api\$1factory** (*Callable*, *opzionale*) — Funzione di fabbrica per la creazione di un'API con cui interagire. HyperPod HyperPod Impostazione predefinita: `None`
+ **abort\$1timeout (*float*, *opzionale*) — Timeout** per interrompere la chiamata nel thread di controllo degli errori. Impostazione predefinita: `None`
+ **enabled** (*bool*, *opzionale*) — Abilita la funzionalità wrapper. Quando`False`, il wrapper diventa un pass-through. Impostazione predefinita: `True`
+ **trace\$1file\$1path** (*str*, *opzionale*) — Percorso del file di traccia per la profilazione. VizTracer Impostazione predefinita: `None`
+ **async\$1raise\$1before\$1abort (bool, opzionale) — Abilita il raise before abort** **nel thread di controllo degli errori.** Impostazione predefinita: `True`
+ **early\$1abort\$1communicator** **(bool, opzionale) — Interrompe il comunicatore (nccl/Gloo) prima di interrompere il dataloader.** Impostazione predefinita: `False`
+ **checkpoint\$1manager** (*Any*, *opzionale*) — Gestore per la gestione dei checkpoint durante il ripristino. Impostazione predefinita: `None`
+ **check\$1memory\$1status** *(*bool*, opzionale) — Abilita il controllo e la registrazione dello stato della memoria.* Impostazione predefinita: `True`
**Metodi**
```
def __call__(self, fn)
```
*Racchiude una funzione per abilitare le funzionalità di riavvio.*
**Parametri:**
+ **fn** (*Callable*) — La funzione da completare con le funzionalità di riavvio
**Restituisce:**
+ **Richiamabile**: funzione racchiusa con funzionalità di riavvio o funzione originale se disabilitata
**Esempio**
```
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
```
**Note**
+ Il wrapper deve essere disponibile `torch.distributed`
+ Quando`enabled=False`, il wrapper diventa un pass-through e restituisce la funzione originale invariata
+ Il wrapper mantiene risorse globali come il monitoraggio dei thread durante tutto il ciclo di vita della formazione
+ Supporta la profilazione quando viene fornita VizTracer `trace_file_path`
+ Si integra HyperPod per una gestione coordinata dei guasti nell'ambito della formazione distribuita
### HPCallInvolucro
```
class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)
```
Monitora e gestisce lo stato di un Restart Code Block (RCB) durante l'esecuzione.
Questa classe gestisce il ciclo di vita dell'esecuzione di RCB, incluso il rilevamento degli errori, il coordinamento con altri ranghi per i riavvii e le operazioni di pulizia. Gestisce la sincronizzazione distribuita e garantisce un ripristino coerente in tutti i processi di formazione.
**Parametri**
+ **wrapper** (*HPWrapper*) — Il wrapper principale contenente le impostazioni globali di ripristino durante il processo
**Attributes**
+ **step\$1upon\$1restart** (*int*) — Contatore che tiene traccia dei passaggi dall'ultimo riavvio, utilizzato per determinare la strategia di riavvio
**Metodi**
```
def initialize_barrier()
```
Attendi la sincronizzazione della HyperPod barriera dopo aver riscontrato un'eccezione da RCB.
```
def start_hp_fault_handling_thread()
```
Avvia il thread di gestione degli errori per monitorare e coordinare gli errori.
```
def handle_fn_exception(call_ex)
```
Elabora le eccezioni dalla funzione di esecuzione o da RCB.
**Parametri:**
+ **call\$1ex** (*Exception) — Eccezione* dalla funzione di monitoraggio
```
def restart(term_ex)
```
Esegue il gestore di riavvio che include la finalizzazione, la raccolta dei rifiuti e i controlli di integrità.
**Parametri:**
+ **term\$1ex** (*RankShouldRestart*) — Eccezione di terminazione che attiva il riavvio
```
def launch(fn, *a, **kw)
```
*Esegui l'RCB con una corretta gestione delle eccezioni.*
**Parametri:**
+ **fn** (*Callable*) — Funzione da eseguire
+ **a — Argomenti** della funzione
+ **kw** — Argomenti delle parole chiave della funzione
```
def run(fn, a, kw)
```
Ciclo di esecuzione principale che gestisce i riavvii e la sincronizzazione delle barriere.
**Parametri:**
+ **fn** (*Callable*) — Funzione da eseguire
+ **a — Argomenti** della funzione
+ **kw** — Argomenti delle parole chiave della funzione
```
def shutdown()
```
Gestione degli errori di spegnimento e thread di monitoraggio.
**Note**
+ Gestisce automaticamente le `RankShouldRestart` eccezioni per un ripristino coordinato
+ Gestisce il tracciamento e gli aborti della memoria, la raccolta dei rifiuti durante i riavvii
+ Supporta sia il ripristino in corso che le strategie PLR (Process-Level Restart) basate sulla tempistica degli errori
### CudaHealthCheck
```
class hyperpod_checkpointless_training.inprocess.health_check.CudaHealthCheck(timeout=datetime.timedelta(seconds=30))
```
Assicura che il contesto CUDA per il processo corrente sia in buono stato durante il recupero dall'allenamento senza checkpoint.
Questo controllo di integrità si sincronizza con la GPU per verificare che il contesto CUDA non sia danneggiato dopo un errore di allenamento. Esegue operazioni di sincronizzazione della GPU per rilevare eventuali problemi che potrebbero impedire la corretta ripresa dell'allenamento. Il controllo dello stato viene eseguito dopo la distruzione dei gruppi distribuiti e il completamento della finalizzazione.
**Parametri**
+ **timeout** (*datetime.timedelta, *opzionale*) — Durata del timeout* per le operazioni di sincronizzazione della GPU. Impostazione predefinita: `datetime.timedelta(seconds=30)`
**Metodi**
```
__call__(state, train_ex=None)
```
Esegui il controllo dello stato di salute CUDA per verificare l'integrità del contesto della GPU.
**Parametri:**
+ **state (*HPState*) — HyperPod Stato** attuale contenente informazioni sulla classificazione e sulla distribuzione
+ **train\$1ex** (*Eccezione*, *opzionale*) — L'eccezione di allenamento originale che ha attivato il riavvio. Impostazione predefinita: `None`
**Restituisce:**
+ **tuple** — Una tupla che contiene `(state, train_ex)` invariate le modifiche se il controllo sanitario ha esito positivo
**Aumenta:**
+ **TimeoutError**— Se la sincronizzazione della GPU scade, indica un contesto CUDA potenzialmente danneggiato
**Conservazione dello stato**: restituisce lo stato e l'eccezione originali invariati se tutti i controlli vengono superati
**Esempio**
```
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
```
**Note**
+ Utilizza il threading per implementare la protezione da timeout per la sincronizzazione della GPU
+ Progettato per rilevare contesti CUDA danneggiati che potrebbero impedire la corretta ripresa dell'allenamento
+ Dovrebbe essere utilizzato come parte della pipeline di tolleranza agli errori negli scenari di formazione distribuiti
### HPAgentK8s APIFactory
```
class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()
```
Classe Factory per la creazione di istanze HPAgent K8SAPi che comunicano con HyperPod l'infrastruttura per il coordinamento distribuito della formazione.
Questa factory fornisce un modo standardizzato per creare e configurare oggetti HPAgent K8SAPi che gestiscono la comunicazione tra i processi di addestramento e il piano di controllo. HyperPod Incapsula la creazione del client socket sottostante e dell'istanza API, garantendo una configurazione coerente tra le diverse parti del sistema di formazione.
**Metodi**
```
__call__()
```
Crea e restituisci un'istanza HPAgent K8SAPi configurata per la comunicazione. HyperPod
**Restituisce:**
+ **HPAgentK8sapi**: istanza API configurata per la comunicazione con l'infrastruttura HyperPod
**Esempio**
```
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
```
**Note**
+ Progettato per funzionare perfettamente con l'infrastruttura basata su Kubernetes. HyperPod È essenziale per la gestione e il ripristino coordinati dei guasti in scenari di formazione distribuiti
### CheckpointManager
```
class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.CheckpointManager(
enable_checksum=False,
enable_offload=False)
```
Gestisce i checkpoint in memoria e peer-to-peer il ripristino per una tolleranza agli errori senza checkpoint nell'addestramento distribuito.
Questa classe fornisce le funzionalità di base per un addestramento HyperPod senza checkpoint gestendo i checkpoint del NeMo modello in memoria, convalidando la fattibilità del recupero e orchestrando il trasferimento dei checkpoint tra i ranghi sani e quelli falliti. peer-to-peer Elimina la necessità del disco I/O durante il ripristino, riducendo in modo significativo il tempo medio di ripristino (MTTR).
**Parametri**
+ **enable\$1checksum** (*bool*, *opzionale*) — Abilita la convalida del checksum dello stato del modello per i controlli di integrità durante il ripristino. Impostazione predefinita: `False`
+ **enable\$1offload (*bool*, *opzionale*) — Abilita l'offload** dei checkpoint dalla GPU alla memoria della CPU per ridurre l'utilizzo della memoria della GPU. Impostazione predefinita: `False`
**Attributes**
+ **global\$1step (int o None) — Fase** *di allenamento corrente associata al checkpoint* *salvato*
+ **rng\$1states (*list* o *None*) — Stati** del generatore di numeri casuali memorizzati per il recupero deterministico
+ **checksum\$1manager** (*MemoryChecksumManager*) — Gestore per la convalida del checksum dello stato del modello
+ **parameter\$1update\$1lock (**) — Blocco per coordinare gli aggiornamenti dei parametri durante il ripristino *ParameterUpdateLock*
**Metodi**
```
save_checkpoint(trainer)
```
Salva il checkpoint del NeMo modello in memoria per un potenziale ripristino senza checkpoint.
**Parametri:**
+ **trainer (*Pytorch\$1Lightning.trainer***) — Istanza del trainer Lightning PyTorch
**Note:**
+ Chiamato CheckpointlessCallback alla fine del batch o durante la gestione delle eccezioni
+ Crea punti di ripristino senza I/O sovraccarico del disco
+ Memorizza gli stati completi del modello, dell'ottimizzatore e dello scheduler
```
delete_checkpoint()
```
Elimina il checkpoint in memoria ed esegui le operazioni di pulizia.
**Note:**
+ Cancella i dati del checkpoint, gli stati RNG e i tensori memorizzati nella cache
+ Esegue la raccolta dei rifiuti e la pulizia della cache CUDA
+ Chiamato dopo il ripristino riuscito o quando il checkpoint non è più necessario
```
try_checkpointless_load(trainer)
```
Tenta il ripristino senza checkpoint caricando lo stato dai ranghi dei peer ranks.
**Parametri:**
+ **trainer (*PyTorch\$1Lightning.trainer***) — Istanza del trainer Lightning PyTorch
**Restituisce:**
+ **dict** o **None**: checkpoint ripristinato in caso di successo, Nessuno se è necessario eseguire il fallback su disco
**Note:**
+ Punto di accesso principale per il ripristino senza checkpoint
+ Convalida la fattibilità del ripristino prima di tentare il trasferimento P2P
+ Pulisce sempre i checkpoint in memoria dopo il tentativo di ripristino
```
checkpointless_recovery_feasible(trainer, include_checksum_verification=True)
```
Determina se è possibile un ripristino senza checkpoint per lo scenario di errore corrente.
**Parametri:**
+ **trainer (*Pytorch\$1Lightning.trainer***) — Istanza del trainer Lightning PyTorch
+ **include\$1checksum\$1verification (bool, opzionale) — **Se includere la** convalida del checksum.** Impostazione predefinita: `True`
**Restituisce:**
+ **bool** — Vero se il ripristino senza checkpoint è fattibile, False altrimenti
**Criteri di convalida:**
+ Coerenza globale dei passaggi tra i ranghi più sani
+ Sono disponibili sufficienti repliche sane per il ripristino
+ Integrità del checksum dello stato del modello (se abilitata)
```
store_rng_states()
```
Memorizza tutti gli stati del generatore di numeri casuali per il ripristino deterministico.
**Note:**
+ Cattura gli stati RNG di Python NumPy PyTorch , CPU/GPU e Megatron
+ Essenziale per mantenere il determinismo dell'allenamento dopo il recupero
```
load_rng_states()
```
Ripristina tutti gli stati RNG per una continuazione deterministica del recupero.
**Note:**
+ Ripristina tutti gli stati RNG precedentemente memorizzati
+ Assicura che l'allenamento continui con sequenze casuali identiche
```
maybe_offload_checkpoint()
```
Sposta il checkpoint dalla GPU alla memoria della CPU se l'offload è abilitato.
**Note:**
+ Riduce l'utilizzo della memoria della GPU per i modelli di grandi dimensioni
+ Viene eseguito solo se `enable_offload=True`
+ Mantiene l'accessibilità ai checkpoint per il ripristino
**Esempio**
```
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
```
**Convalida**: verifica l'integrità del checkpoint utilizzando i checksum (se abilitati)
**Note**
+ Utilizza primitive di comunicazione distribuite per un trasferimento P2P efficiente
+ Gestisce automaticamente le conversioni di tipo d del tensore e il posizionamento dei dispositivi
+ **MemoryChecksumManager**— Gestisce la convalida dell'integrità dello stato del modello
### PEFTCheckpointGestore
```
class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.PEFTCheckpointManager(
*args,
**kwargs)
```
Gestisce i checkpoint per PEFT (Parameter-Efficient Fine-Tuning) con gestione separata della base e dell'adattatore per un ripristino ottimizzato senza checkpoint.
Questo gestore di checkpoint specializzato consente di ottimizzare i flussi di lavoro PEFT separando CheckpointManager i pesi del modello base dai parametri dell'adattatore.
**Parametri**
Eredita tutti i parametri da: **CheckpointManager**
+ **enable\$1checksum** (*bool*, *opzionale*) — Abilita la convalida del checksum dello stato del modello. Impostazione predefinita: `False`
+ **enable\$1offload (*bool*, opzionale) — Abilita l'offloading del checkpoint** *nella memoria della CPU.* Impostazione predefinita: `False`
**Attributi aggiuntivi**
+ **params\$1to\$1save** (*set) — Set* di nomi di parametri che devono essere salvati come parametri dell'adattatore
+ **base\$1model\$1weights (*dict* o None) — Pesi** *del modello base memorizzati nella cache, salvati una volta e riutilizzati*
+ ****base\$1model\$1keys\$1to\$1extract (list o None) — Chiavi per estrarre i tensori del modello base durante il trasferimento P2P****
**Metodi**
```
maybe_save_base_model(trainer)
```
Salva i pesi del modello base una volta, filtrando i parametri dell'adattatore.
**Parametri:**
+ **trainer (*PyTorch\$1Lightning.trainer***) — Istanza del trainer Lightning PyTorch
**Note:**
+ Salva i pesi del modello base solo alla prima chiamata; le chiamate successive non sono operative
+ Filtra i parametri dell'adattatore per memorizzare solo i pesi del modello base congelati
+ I pesi del modello base vengono mantenuti per più sessioni di allenamento
```
save_checkpoint(trainer)
```
Salva il checkpoint del modello di adattatore NeMo PEFT in memoria per un potenziale ripristino senza checkpoint.
**Parametri:**
+ **trainer (*PyTorch\$1Lightning.trainer***) — Istanza di Lightning trainer PyTorch
**Note:**
+ `maybe_save_base_model()`Chiama automaticamente se il modello base non è ancora stato salvato
+ Filtra il checkpoint per includere solo i parametri dell'adattatore e lo stato di allenamento
+ Riduce in modo significativo le dimensioni dei checkpoint rispetto ai checkpoint del modello completo
```
try_base_model_checkpointless_load(trainer)
```
Il modello base di Attempt PEFT soppesa il ripristino senza checkpoint caricando lo stato dai ranghi dei peer rank.
**Parametri:**
+ *trainer (**PyTorch\$1Lightning.trainer) — Istanza del trainer Lightning*** PyTorch
**Restituisce:**
+ **dict** o **None** — Il checkpoint del modello base è stato ripristinato in caso di successo, None se è necessario il fallback
**Note:**
+ Utilizzato durante l'inizializzazione del modello per recuperare i pesi del modello base
+ Non elimina i pesi del modello base dopo il ripristino (li conserva per il riutilizzo)
+ Ottimizzato per scenari di ripristino model-weights-only
```
try_checkpointless_load(trainer)
```
L'adattatore PEFT di Attempt soppesa il ripristino senza checkpoint caricando lo stato dai ranghi dei colleghi.
**Parametri:**
+ *trainer (**PyTorch\$1Lightning.trainer) — Istanza di Lightning trainer*** PyTorch
**Restituisce:**
+ **dict** o **None** — Il checkpoint dell'adattatore è stato ripristinato in caso di successo, Nessuno se è necessario il fallback
**Note:**
+ Recupera solo i parametri dell'adattatore, gli stati dell'ottimizzatore e gli scheduler
+ Carica automaticamente gli stati dell'ottimizzatore e dello scheduler dopo il ripristino riuscito
+ Pulisce i checkpoint dell'adattatore dopo il tentativo di ripristino
```
is_adapter_key(key)
```
Controlla se la chiave state dict appartiene ai parametri dell'adattatore.
**Parametri:**
+ **key** (*str* o *tuple*) — Chiave dict di stato da controllare
**Restituisce:**
+ **bool** — Vero se la chiave è il parametro dell'adattatore, False se è il parametro del modello base
**Logica di rilevamento:**
+ Controlla se la chiave è `params_to_save` impostata
+ Identifica le chiavi contenenti «.adapter». substring
+ Identifica le chiavi che terminano con «.adapters»
+ Per le chiavi tuple, controlla se il parametro richiede gradienti
```
maybe_offload_checkpoint()
```
Scarica i pesi del modello base dalla GPU alla memoria della CPU.
**Note:**
+ Estende il metodo principale per gestire lo scaricamento del peso del modello base
+ I pesi degli adattatori sono in genere piccoli e non richiedono lo scarico
+ Imposta un flag interno per tracciare lo stato di offload
**Note**
+ Progettato specificamente per scenari di fine-tuning efficienti dal punto di vista dei parametri (LoRa, adattatori, ecc.)
+ Gestisce automaticamente la separazione dei parametri del modello base e dell'adattatore
**Esempio**
```
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()
```
Classe Factory per la creazione e la gestione delle composizioni dei componenti di interruzione per una tolleranza ai guasti senza checkpoint.
Questa classe di utilità fornisce metodi statici per creare, personalizzare e gestire le composizioni dei componenti di aborto utilizzate durante la gestione dei guasti durante la formazione senza checkpoint. HyperPod Semplifica la configurazione delle sequenze di interruzione che gestiscono la pulizia dei componenti di formazione distribuiti, dei caricatori di dati e delle risorse specifiche del framework durante il ripristino in caso di errore.
**Parametri**
Nessuno (tutti i metodi sono statici)
**Metodi statici**
```
get_default_checkpointless_abort()
```
Ottieni l'istanza abort compose predefinita contenente tutti i componenti di abort standard.
**Restituisce:**
+ **Componi**: istanza di interruzione composta predefinita con tutti i componenti di interruzione
**Componenti predefiniti:**
+ **AbortTransformerEngine()** — Pulisce le risorse TransformerEngine
+ **HPCheckpointingAbort ()** — Gestisce la pulizia del sistema di checkpoint
+ **HPAbortTorchDistributed()** — Interrompe le operazioni distribuite PyTorch
+ **HPDataLoaderAbort()** — Arresta e pulisce i caricatori di dati
```
create_custom_abort(abort_instances)
```
*Crea una composizione di interruzione personalizzata con solo le istanze di interruzione specificate.*
**Parametri:**
+ **abort\$1instances** (*Abort) — Numero variabile di istanze di aborto* da includere nella composizione
**Restituisce:**
+ **Componi** — Nuova istanza di interruzione composta contenente solo i componenti specificati
**Aumenta:**
+ **ValueError**— Se non vengono fornite istanze di interruzione
```
override_abort(abort_compose, abort_type, new_abort)
```
Sostituisci un componente di interruzione specifico in un'istanza Compose con un nuovo componente.
**Parametri:**
+ **abort\$1compose (Compose**) — L'*istanza Compose* originale da modificare
+ **abort\$1type (type**) — Il *tipo di componente di* interruzione da sostituire (ad esempio,) `HPCheckpointingAbort`
+ **new\$1abort** (Abort) — La nuova istanza di *abort* da utilizzare come sostituto
**Restituisce:**
+ **Compose** — Nuova istanza Compose con il componente specificato sostituito
**Aumenta:**
+ **ValueError**— Se abort\$1compose non ha l'attributo 'instances'
**Esempio**
```
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(...)
```
**Note**
+ Le configurazioni personalizzate consentono un controllo preciso sul comportamento di pulizia
+ Le operazioni di interruzione sono fondamentali per una corretta pulizia delle risorse durante il ripristino dei guasti
### CheckpointlessFinalizeCleanup
```
class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()
```
Esegue una pulizia completa dopo il rilevamento dei guasti per prepararsi al ripristino in corso durante l'addestramento senza checkpoint.
Questo gestore di finalizzazione esegue operazioni di pulizia specifiche del framework, tra cui Megatron/TransformerEngine interruzione, pulizia DDP, ricaricamento dei moduli e pulizia della memoria, eliminando i riferimenti ai componenti di addestramento. Garantisce che l'ambiente di formazione venga ripristinato correttamente per il corretto ripristino durante il processo senza richiedere l'interruzione completa del processo.
**Parametri**
Nessuno
**Attributes**
+ **trainer** *(*Pytorch\$1Lightning.trainer o None) — Riferimento all'istanza del trainer Lightning** PyTorch
**Metodi**
```
__call__(*a, **kw)
```
**Esegui operazioni di pulizia complete per la preparazione del ripristino durante il processo.**
*Parametri:*
+ **a** — Argomenti posizionali variabili (ereditati dall'interfaccia Finalize)
+ **kw** — Argomenti variabili relativi alle parole chiave (ereditati dall'interfaccia Finalize)
**Operazioni di pulizia:**
+ **Megatron Framework Cleanup**: chiamate per ripulire le risorse specifiche `abort_megatron()` di Megatron
+ **TransformerEngine Cleanup: chiamate per ripulire le risorse** `abort_te()` TransformerEngine
+ **RoPE Cleanup**: chiamate `cleanup_rope()` per ripulire le risorse di incorporamento della posizione rotante
+ **DDP Cleanup: chiamate per ripulire** le risorse `cleanup_ddp()` DistributedDataParallel
+ **Module Reloading: chiamate `reload_megatron_and_te()` per ricaricare** i moduli del framework
+ **Pulizia del modulo Lightning: cancella facoltativamente il** modulo Lightning per ridurre la memoria della GPU
+ **Memory Cleanup**: elimina i riferimenti ai componenti di addestramento per liberare memoria
```
register_attributes(trainer)
```
*Registra l'istanza del trainer per utilizzarla durante le operazioni di pulizia.*
**Parametri:**
+ **trainer** (*PyTorch\$1Lightning.trainer) — Istanza di Lightning* trainer da registrare PyTorch
**Integrazione con 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(...)
```
**Note**
+ Le operazioni di pulizia vengono eseguite in un ordine specifico per evitare problemi di dipendenza
+ La pulizia della memoria utilizza l'introspezione della raccolta dei rifiuti per trovare gli oggetti di destinazione
+ Tutte le operazioni di pulizia sono progettate per essere idempotenti e sicure da riprovare
### CheckpointlessMegatronStrategy
```
class hyperpod_checkpointless_training.nemo_plugins.megatron_strategy.CheckpointlessMegatronStrategy(*args, **kwargs)
```
NeMo Strategia Megatron con funzionalità integrate di ripristino senza checkpoint per una formazione distribuita con tolleranza ai guasti.
Tieni presente che l'addestramento senza checkpoint deve essere almeno 2 in `num_distributed_optimizer_instances` modo da garantire la replica dell'ottimizzatore. La strategia si occupa anche della registrazione degli attributi essenziali e dell'inizializzazione dei gruppi di processi.
**Parametri**
Eredita tutti i parametri da: **MegatronStrategy**
+ NeMo MegatronStrategy Parametri di inizializzazione standard
+ Opzioni di configurazione della formazione distribuita
+ Impostazioni del parallelismo del modello
**Attributes**
+ **base\$1store** *(torch.distributed). TCPStore*o *Nessuno*) — Archivio distribuito per il coordinamento dei gruppi di processi
**Metodi**
```
setup(trainer)
```
Inizializza la strategia e registra i componenti di tolleranza ai guasti con il trainer.
**Parametri:**
+ **trainer (*PyTorch\$1Lightning.trainer***) — Istanza del trainer Lightning PyTorch
**Operazioni di configurazione:**
+ **Parent Setup**: richiama la MegatronStrategy configurazione principale
+ **Fault Injection Registration**: registra HPFault InjectionCallback gli hook, se presenti
+ **Finalizza la registrazione**: registra il trainer con i gestori di finalize cleanup
+ Interrompi la **registrazione: registra il trainer con i gestori di aborti che lo supportano**
```
setup_distributed()
```
Inizializza il gruppo di processi utilizzando una connessione con prefisso o senza root. TCPStore
```
load_model_state_dict(checkpoint, strict=True)
```
Carica il modello state dict con compatibilità di ripristino senza checkpointless.
**Parametri:**
+ **checkpoint** (*Mapping [str, Any]*) — Dizionario Checkpoint contenente lo stato del modello
+ **strict** (*bool*, *optional*) — Se applicare rigorosamente la corrispondenza delle chiavi state dict. Impostazione predefinita: `True`
```
get_wrapper()
```
Ottieni l'istanza HPCall Wrapper per il coordinamento della tolleranza agli errori.
**Restituisce:**
+ **HPCallWrapper**: l'istanza wrapper collegata al trainer per la tolleranza agli errori
```
is_peft()
```
Controlla se PEFT (Parameter-Efficient Fine-Tuning) è abilitato nella configurazione di addestramento verificando la presenza di callback PEFT
**Restituisce:**
+ **bool** — Vero se è presente il callback PEFT, False in caso contrario
```
teardown()
```
Sostituisci lo smontaggio nativo di PyTorch Lightning per delegare la pulizia ai gestori di aborti.
**Esempio**
```
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)
```
Lightning callback che integra la formazione con il sistema di tolleranza ai guasti di checkpointless training. NeMo
Questo callback gestisce il tracciamento dei passaggi, il salvataggio dei checkpoint e il coordinamento dell'aggiornamento dei parametri per le funzionalità di ripristino durante il processo. Funge da punto di integrazione principale tra i cicli di formazione PyTorch Lightning e i meccanismi di addestramento HyperPod senza checkpoint, coordinando le operazioni di tolleranza agli errori durante l'intero ciclo di vita della formazione.
**Parametri**
+ ****enable\$1inprocess (bool, opzionale) — Abilita le funzionalità di ripristino durante il processo.**** Impostazione predefinita: `False`
+ **enable\$1checkpointless (*bool*, opzionale) — Abilita il ripristino senza checkpointless** *(richiesto).* `enable_inprocess=True` Impostazione predefinita: `False`
+ **enable\$1checksum (bool, opzionale) — Abilita la convalida del checksum** *dello stato del modello (richiesto**).* `enable_checkpointless=True` Impostazione predefinita: `False`
+ **clean\$1tensor\$1hook (*bool*, opzionale) — Elimina gli hook** *tensoriali da tutti i tensori della GPU durante la pulizia (operazione* costosa). Impostazione predefinita: `False`
+ **clean\$1lightning\$1module (bool, opzionale) — Abilita la pulizia del modulo Lightning** **per liberare memoria della GPU dopo ogni riavvio.** Impostazione predefinita: `False`
**Attributes**
+ **tried\$1adapter\$1checkpointless** *(bool) — Contrassegna per verificare se è stato tentato il ripristino senza checkpointless dell'adattatore*
**Metodi**
```
get_wrapper_from_trainer(trainer)
```
Scarica l'istanza Wrapper dal trainer per il coordinamento della tolleranza agli errori. HPCall
**Parametri:**
+ **trainer (*PyTorch\$1Lightning.trainer***) — Istanza del trainer Lightning PyTorch
**Restituisce:**
+ **HPCallWrapper**: l'istanza wrapper per le operazioni di tolleranza ai guasti
```
on_train_batch_start(trainer, pl_module, batch, batch_idx, *args, **kwargs)
```
Richiamato all'inizio di ogni batch di allenamento per gestire il monitoraggio e il recupero delle fasi.
**Parametri:**
+ **trainer** (*PyTorch\$1Lightning.trainer) — Istanza di Lightning* trainer PyTorch
+ **pl\$1module** (*pytorch\$1lightning). LightningModule*) — Modulo Lightning in fase di addestramento
+ **batch: dati** correnti relativi al batch di addestramento
+ **batch\$1idx** (*int*) — Indice del batch corrente
+ args — **Argomenti** posizionali aggiuntivi
+ **kwargs** — Argomenti aggiuntivi relativi alle parole chiave
```
on_train_batch_end(trainer, pl_module, outputs, batch, batch_idx)
```
*Rilascia il blocco di aggiornamento dei parametri alla fine di ogni batch di addestramento.*
**Parametri:**
+ **trainer** (*Pytorch\$1Lightning.trainer) — Istanza del trainer Lightning* PyTorch
+ **pl\$1module** (*pytorch\$1lightning). LightningModule*) — Modulo Lightning in fase di addestramento
+ **outputs** (*STEP\$1OUTPUT) — Uscite* della fase di addestramento
+ **batch (Any**) — *Dati* correnti del batch di addestramento
+ **batch\$1idx** (*int*) — Indice del batch corrente
**Note:**
+ La tempistica di rilascio del blocco garantisce che il ripristino senza checkpoint possa procedere dopo il completamento degli aggiornamenti dei parametri
+ Viene eseguito solo quando entrambi i valori sono impostati su True `enable_inprocess` `enable_checkpointless`
```
get_peft_callback(trainer)
```
*Recupera il callback PEFT dall'elenco dei callback del trainer.*
**Parametri:**
+ *trainer (**Pytorch\$1Lightning.trainer**) — Istanza del trainer Lightning* PyTorch
**Restituisce:**
+ **PEFT** o **None**: istanza di callback PEFT se trovata, nessuna in caso contrario
```
_try_adapter_checkpointless_restore(trainer, params_to_save)
```
*Tenta il ripristino senza checkpoint dei parametri dell'adattatore PEFT.*
**Parametri:**
+ **trainer (*Pytorch\$1Lightning.trainer***) — Istanza di Lightning trainer PyTorch
+ ***params\$1to\$1save (set) — Set di nomi di parametri da salvare come parametri dell'adattatore***
**Note:**
+ Viene eseguito solo una volta per sessione di allenamento (controllata da flag) `tried_adapter_checkpointless`
+ Configura il gestore dei punti di controllo con le informazioni sui parametri dell'adattatore
**Esempio**
```
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)
```
**Gestione della memoria**
+ **clean\$1tensor\$1hook: rimuove i ganci tensoriali** durante la pulizia (costoso ma completo)
+ **clean\$1lightning\$1module**: libera memoria GPU del modulo Lightning durante i riavvii
+ Entrambe le opzioni aiutano a ridurre l'ingombro di memoria durante il ripristino dei guasti
+ Coordinate con ParameterUpdateLock per il tracciamento degli aggiornamenti dei parametri thread-safe
### CheckpointlessCompatibleConnector
```
class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()
```
PyTorch Connettore Lightning Checkpoint che integra il ripristino senza checkpoint con il tradizionale caricamento dei checkpoint basato su disco.
Questo connettore estende quello di PyTorch Lightning per fornire una perfetta integrazione tra il ripristino senza checkpoint e `_CheckpointConnector` il ripristino dei checkpoint standard. Tenta innanzitutto il ripristino senza checkpoint, quindi torna al caricamento del checkpoint basato su disco se il ripristino senza checkpoint non è fattibile o fallisce.
**Parametri**
**Eredita** tutti i parametri da \$1 CheckpointConnector
**Metodi**
```
resume_start(checkpoint_path=None)
```
Tentativo di precaricare il checkpoint con priorità di ripristino senza checkpointless.
**Parametri:**
+ **checkpoint\$1path** (*str* o *None*, *opzionale*) — Percorso verso il checkpoint del disco per il fallback. Impostazione predefinita: `None`
```
resume_end()
```
Completa il processo di caricamento del checkpoint ed esegui le operazioni successive al caricamento.
**Note**
+ Estende la `_CheckpointConnector` classe interna di PyTorch Lightning con il supporto per il ripristino senza checkpoint
+ Mantiene la piena compatibilità con i flussi di lavoro Lightning checkpoint standard PyTorch
### CheckpointlessAutoResume
```
class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()
```
Estende NeMo la funzionalità AutoResume con configurazione ritardata per consentire la convalida del ripristino senza checkpoint prima della risoluzione del percorso di checkpoint.
Questa classe implementa una strategia di inizializzazione in due fasi che consente la convalida del ripristino senza checkpoint prima di tornare al tradizionale caricamento dei checkpoint basato su disco. Ritarda in modo condizionale la AutoResume configurazione per impedire la risoluzione prematura del percorso dei checkpoint, permettendo di verificare innanzitutto se il ripristino senza checkpoint è fattibile. CheckpointManager peer-to-peer
**Parametri**
Eredita tutti i parametri da **AutoResume**
**Metodi**
```
setup(trainer, model=None, force_setup=False)
```
Ritarda la AutoResume configurazione in modo condizionale per consentire la convalida del ripristino senza checkpoint.
**Parametri:**
+ **trainer (Pytorch\$1Lightning.trainer o** *lightning.Fabric.fabric) — Lightning* *trainer o istanza Fabric* PyTorch
+ **model** *(opzionale) — Istanza* del modello per la configurazione. Impostazione predefinita: `None`
+ **force\$1setup** (*bool*, *opzionale*) — Se True, ignora il ritardo ed esegui immediatamente la configurazione. AutoResume Impostazione predefinita: `False`
**Esempio**
```
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()
)
```
**Note**
+ La AutoResume classe NeMo di Extends con meccanismo di ritardo per consentire il ripristino senza checkpoint
+ Funziona in combinazione con `CheckpointlessCompatibleConnector` per un flusso di lavoro di ripristino completo
# Considerazioni speciali
Raccogliamo determinate metriche operative aggregate e anonime di routine per fornire la disponibilità essenziale del servizio. La creazione di queste metriche è completamente automatizzata e non prevede la revisione umana del carico di lavoro di formazione del modello sottostante. Queste metriche riguardano le operazioni lavorative, la gestione delle risorse e le funzionalità essenziali dei servizi.
HyperPod checkpoint gestito su più livelli e formazione elastica: tieni presente che la formazione HyperPod senza checkpoint è attualmente incompatibile con HyperPod il checkpointing gestito a più livelli e l'allenamento elastico.
Per semplificare l'avvio, vengono fornite ricette di formazione senza checkpointless per i modelli GPT OSS 120B e Llama. Queste ricette sono state verificate su istanze ml.p5. L'utilizzo di altri tipi di istanze può richiedere ulteriori modifiche alle ricette sottostanti. Queste ricette possono essere adattate anche a flussi di lavoro di ottimizzazione completi. [Per i modelli personalizzati, ti consigliamo di consultare gli esempi introduttivi.](https://docs.aws.amazon.com/sagemaker-eks-checkpointless-recipes-custom)
# Appendice
**Monitora i risultati dell'allenamento tramite HyperPod ricette**
SageMaker HyperPod le ricette offrono l'integrazione con Tensorboard per analizzare il comportamento di allenamento. Queste ricette includono VizTracer anche uno strumento a basso costo per tracciare e visualizzare l'esecuzione del codice Python. Per ulteriori informazioni, consulta [ VizTracer](https://github.com/gaogaotiantian/viztracer).
I log di tensorboard vengono generati e archiviati all'interno di. `log_dir` Per accedere ai log e analizzarli in locale, procedi come indicato di seguito:
1. Scarica la cartella degli esperimenti TensorBoard dal tuo ambiente di addestramento al computer locale.
1. Apri un prompt del terminale o di comando sul tuo computer locale.
1. Passa alla directory che contiene la cartella degli esperimenti scaricata.
1. Avvia Tensorboard eseguendo il comando:
```
tensorboard --port= --bind_all --logdir experiment.
```
1. Apri il tuo browser web e visita. `http://localhost:8008`
Ora puoi vedere lo stato e le visualizzazioni dei tuoi job di addestramento all’interno dell’interfaccia TensorBoard. L’accesso allo stato e alle visualizzazioni consente di monitorare e analizzare il processo di addestramento. Il monitoraggio e l’analisi del processo di addestramento consentono di ottenere informazioni approfondite sul comportamento e sulle prestazioni dei modelli. Per ulteriori informazioni su come monitorare e analizzare l'allenamento con Tensorboard, consulta la Guida per l'utente di [NVIDIA Framework NeMo ](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/core/exp_manager.html#experiment-manager).
**VizTracer**
Per abilitarlo VizTracer, puoi modificare la tua ricetta impostando la variabile di ambiente su. `ENABLE_VIZTRACER` `1` Una volta completata la formazione, il tuo VizTracer profilo si trova nella cartella dell'esperimento`log_dir/viztracer_xxx.json`. Per analizzare il tuo profilo, puoi scaricarlo e aprirlo utilizzando lo **vizviewer** strumento:
```
vizviewer --port viztracer_xxx.json
```
Questo comando avvia vizviewer sulla porta 9001. Puoi visualizzarlo VizTracer andando su http://localhost: nel tuo browser. Dopo l'apertura VizTracer, iniziate ad analizzare il training. Per ulteriori informazioni sull'utilizzo VizTracer, consultate [ VizTracer la documentazione](https://viztracer.readthedocs.io/en/latest/installation.html).
# Note di rilascio
Consulta le seguenti note di rilascio per tenere traccia degli ultimi aggiornamenti per la formazione SageMaker HyperPod senza checkpoint.
**La formazione senza SageMaker HyperPod checkpointless v1.0.0**
Data: 03 dicembre 2025
**SageMaker HyperPod funzionalità di allenamento senza checkpointless**
+ **Miglioramenti all'inizializzazione della comunicazione collettiva**: offre nuovi metodi di inizializzazione, Rootless e per NCCL e Gloo. TCPStoreless
+ Dataloader **con mappatura in memoria (MMAP): memorizza** nella cache (persistono) i batch precaricati in modo che siano disponibili anche quando un errore causa il riavvio del processo di formazione.
+ **Checkpointless**: consente un ripristino più rapido dagli errori di training dei cluster in ambienti di formazione distribuiti su larga scala apportando ottimizzazioni a livello di framework
+ **Basato su Nvidia Nemo e PyTorch Lightning: sfrutta questi potenti framework per una formazione dei modelli efficiente e flessibile**
+ [Nividia NeMo](https://github.com/NVIDIA-NeMo/NeMo)
+ [PyTorch Fulmine](https://lightning.ai/docs/pytorch/stable/)
**SageMaker HyperPod Contenitore Docker di formazione Checkpointless**
[Checkpointless training on HyperPod si basa sul framework NVIDIA. NeMo ](https://docs.nvidia.com/nemo-framework/user-guide/latest/overview.html) HyperPod checkpointless training mira a recuperare più rapidamente gli errori di formazione su cluster in ambienti di formazione distribuiti su larga scala effettuando ottimizzazioni a livello di framework che verranno fornite su un contenitore di base contenente l'immagine di base con NCCL e ottimizzazioni. PyTorch
**Disponibilità**
Attualmente le immagini sono disponibili solo in:
```
eu-north-1
ap-south-1
us-east-2
eu-west-1
eu-central-1
sa-east-1
us-east-1
eu-west-2
ap-northeast-1
us-west-2
us-west-1
ap-southeast-1
ap-southeast-2
```
ma non disponibile nelle seguenti 3 regioni opzionali:
```
ap-southeast-3
ap-southeast-4
eu-south-2
```
**Dettagli container**
Contenitore Docker di formazione Checkpointless per PyTorch la versione 2.6.0 con CUDA v12.9
```
963403601044.dkr.ecr.eu-north-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
423350936952.dkr.ecr.ap-south-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
556809692997.dkr.ecr.us-east-2.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
942446708630.dkr.ecr.eu-west-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
391061375763.dkr.ecr.eu-central-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
311136344257.dkr.ecr.sa-east-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
327873000638.dkr.ecr.us-east-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
016839105697.dkr.ecr.eu-west-2.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
356859066553.dkr.ecr.ap-northeast-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
920498770698.dkr.ecr.us-west-2.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
827510180725.dkr.ecr.us-west-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
885852567298.dkr.ecr.ap-southeast-1.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
304708117039.dkr.ecr.ap-southeast-2.amazonaws.com/hyperpod-checkpointless-training:v1.0.0
```
**Pacchetti preinstallati**
```
PyTorch: v2.6.0
CUDA: v12.9
NCCL: v2.27.5
EFA: v1.43.0
AWS-OFI-NCCL v1.16.0
Libfabric version 2.1
Megatron v0.15.0
Nemo v2.6.0rc0
```