Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Restauration en cours de processus et formation sans points de contrôle

HyperPod l'entraînement sans point de contrôle utilise la redondance des modèles pour permettre un entraînement tolérant aux pannes. Le principe de base est que les états du modèle et de l'optimiseur sont entièrement répliqués sur plusieurs groupes de nœuds, les mises à jour du poids et les changements d'état de l'optimiseur étant répliqués de manière synchrone au sein de chaque groupe. En cas de panne, les répliques saines terminent leurs étapes d'optimisation et transmettent les model/optimizer états mis à jour aux répliques en cours de restauration.

Cette approche basée sur la redondance des modèles permet plusieurs mécanismes de gestion des pannes :

Configurations sans point de contrôle

Voici l'extrait de base de l'entraînement sans point de contrôle.

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

Consultez l'exemple pour ajouter des fonctionnalités d'entraînement sans point de contrôle aux codes.

Concepts

Cette section présente les concepts de formation sans points de contrôle. La formation Checkpointless sur Amazon SageMaker HyperPod prend en charge la restauration en cours de processus. Cette interface API suit un format similaire à celui du NVRx APIs.

Concept - Bloc de code réexécutable (RCB)

En cas d'échec, les processus sains restent actifs, mais une partie du code doit être réexécutée pour récupérer les états d'apprentissage et les piles Python. Un bloc de code réexécutable (RCB) est un segment de code spécifique qui s'exécute à nouveau lors d'une reprise après échec. Dans l'exemple suivant, le RCB englobe l'intégralité du script d'entraînement (c'est-à-dire tout ce qui se trouve sous main ()), ce qui signifie que chaque reprise après échec redémarre le script d'entraînement tout en préservant le modèle en mémoire et les états de l'optimiseur.

Concept - Contrôle des défauts

Un module de contrôle des défaillances reçoit des notifications en cas de panne lors d'un entraînement sans point de contrôle. Ce contrôleur de défauts inclut les composants suivants :

Concept - Redondance du modèle

L'entraînement de grands modèles nécessite généralement une taille de données parallèle suffisamment importante pour entraîner les modèles de manière efficace. Dans le cadre du parallélisme de données traditionnel tel que PyTorch DDP et Horovod, le modèle est entièrement répliqué. Des techniques de parallélisme de données partitionnées plus avancées, telles que l'optimiseur DeepSpeed ZERO et le FSDP, prennent également en charge le mode de partitionnement hybride, qui permet de partitionner les model/optimizer états au sein du groupe de partitionnement et de les répliquer entièrement entre les groupes de réplication. NeMo possède également cette fonctionnalité de partitionnement hybride via un argument num_distributed_optimizer_instances, qui permet la redondance.

Cependant, l'ajout de redondance indique que le modèle ne sera pas entièrement segmenté sur l'ensemble du cluster, ce qui entraînera une augmentation de l'utilisation de la mémoire de l'appareil. La quantité de mémoire redondante varie en fonction des techniques spécifiques de partitionnement du modèle mises en œuvre par l'utilisateur. Les poids, les dégradés et la mémoire d'activation du modèle de faible précision ne seront pas affectés, car ils sont fragmentés par le parallélisme du modèle. Les états du modèle principal de haute précision weights/gradients et de l'optimiseur seront affectés. L'ajout d'une réplique de modèle redondante augmente l'utilisation de la mémoire de l'appareil d'environ l'équivalent de la taille d'un point de contrôle DCP.

Le sharding hybride divise les collectifs de l'ensemble des groupes DP en collectifs relativement plus petits. Auparavant, il y avait une réduction de la diffusion et un regroupement global dans l'ensemble du groupe de personnes déplacées. Après le sharding hybride, la réduction de la diffusion ne s'exécute qu'à l'intérieur de chaque réplique du modèle, et il y aura une réduction totale entre les groupes de répliques de modèles. Le all-gather se déroule également à l'intérieur de chaque réplique du modèle. Par conséquent, l'ensemble du volume de communication reste pratiquement inchangé, mais les collectifs fonctionnent avec des groupes plus restreints. Nous nous attendons donc à une meilleure latence.

Concept - Types de panne et de redémarrage

Le tableau suivant enregistre les différents types de défaillances et les mécanismes de restauration associés. L'entraînement sans point de contrôle tente d'abord de remédier aux défaillances via une restauration en cours de processus, suivie d'un redémarrage au niveau du processus. Il revient à un redémarrage au niveau de la tâche uniquement en cas de panne catastrophique (par exemple, plusieurs nœuds tombent en panne en même temps).

Concept - Protection par verrouillage atomique pour l'étape d'optimisation

L'exécution du modèle est divisée en trois phases : propagation vers l'avant, propagation vers l'arrière et étape d'optimisation. Le comportement de restauration varie en fonction du moment de l'échec :

Cette stratégie garantit que les mises à jour complètes de l'optimiseur ne sont jamais annulées, ce qui contribue à réduire le temps de réparation en cas de panne.

Schéma du flux d'entraînement sans point de contrôle

Les étapes suivantes décrivent le processus de détection des défaillances et de restauration sans point de contrôle :

Référence des API

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Attend et récupère les informations de classement HyperPod, puis met à jour l'environnement de processus actuel avec des variables d'apprentissage distribuées.

Cette fonction obtient l'attribution de grade et les variables d'environnement correctes pour l'entraînement distribué. Cela garantit que chaque processus reçoit la configuration appropriée pour son rôle dans le travail de formation distribué.

Paramètres

Aucune

Renvoie

Aucun

Comportement

Variables d'environnement

La fonction lit les variables d'environnement suivantes :

Augmente

Exemple

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

Remarques

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)

Enveloppeur de fonctions Python qui active les capacités de redémarrage d'un bloc de code réexécutable (RCB) lors d'un entraînement sans point de contrôle. HyperPod

Ce wrapper fournit des fonctionnalités de tolérance aux pannes et de restauration automatique en surveillant l'exécution de la formation et en coordonnant les redémarrages entre les processus distribués en cas de défaillance. Il utilise une approche de gestionnaire de contexte plutôt qu'un décorateur pour gérer les ressources globales tout au long du cycle de vie de la formation.

Paramètres

Méthodes

def __call__(self, fn)

Encapsule une fonction pour activer les fonctionnalités de redémarrage.

Paramètres :

Retours :

Exemple

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

Remarques

HPCallEmballage

class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)

Surveille et gère l'état d'un bloc de code de redémarrage (RCB) pendant son exécution.

Cette classe gère le cycle de vie de l'exécution du RCB, y compris la détection des défaillances, la coordination avec les autres grades pour les redémarrages et les opérations de nettoyage. Il gère la synchronisation distribuée et garantit une restauration cohérente dans tous les processus de formation.

Paramètres

Attributs

Méthodes

def initialize_barrier()

Attendez la synchronisation des HyperPod barrières après avoir rencontré une exception provenant de RCB.

def start_hp_fault_handling_thread()

Démarrez le thread de gestion des pannes pour surveiller et coordonner les défaillances.

def handle_fn_exception(call_ex)

Exceptions de traitement issues de la fonction d'exécution ou du RCB.

Paramètres :

def restart(term_ex)

Exécutez le gestionnaire de redémarrage, y compris la finalisation, le ramassage des déchets et les contrôles de santé.

Paramètres :

def launch(fn, *a, **kw)

Exécutez le RCB avec une gestion appropriée des exceptions.

Paramètres :

def run(fn, a, kw)

Boucle d'exécution principale qui gère les redémarrages et la synchronisation des barrières.

Paramètres :

def shutdown()

Arrêtez les threads de gestion et de surveillance des pannes.

Remarques

CudaHealthCheck

class hyperpod_checkpointless_training.inprocess.health_check.CudaHealthCheck(timeout=datetime.timedelta(seconds=30))

Garantit que le contexte CUDA du processus en cours est en bon état pendant la reprise d'entraînement sans points de contrôle.

Ce contrôle de santé est synchronisé avec le GPU pour vérifier que le contexte CUDA n'est pas endommagé après un échec d'entraînement. Il effectue des opérations de synchronisation du GPU pour détecter tout problème susceptible d'empêcher la reprise réussie de l'entraînement. Le bilan de santé est exécuté une fois que les groupes distribués sont détruits et que la finalisation est terminée.

Paramètres

Méthodes

__call__(state, train_ex=None)

Exécutez le contrôle de santé CUDA pour vérifier l'intégrité du contexte du GPU.

Paramètres :

Retours :

Augmente :

Préservation de l'état : renvoie l'état d'origine et l'exception inchangés si toutes les vérifications sont réussies

Exemple

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

Remarques

HPAgentK8 APIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Classe d'usine permettant de créer des instances HPAgent K8SAPI communiquant avec l' HyperPod infrastructure pour la coordination distribuée des formations.

Cette usine fournit un moyen standardisé de créer et de configurer des objets HPAgent K8SAPI qui gèrent la communication entre les processus de formation et le HyperPod plan de contrôle. Il encapsule la création du client de socket sous-jacent et de l'instance d'API, garantissant ainsi une configuration cohérente entre les différentes parties du système de formation.

Méthodes

__call__()

Créez et renvoyez une instance HPAgent K8SAPI configurée pour la communication. HyperPod

Retours :

Exemple

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

Remarques

CheckpointManager

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.CheckpointManager(  
    enable_checksum=False,  
    enable_offload=False)

Gère les points de contrôle en mémoire et la peer-to-peer restauration pour une tolérance aux pannes sans point de contrôle dans le cadre de la formation distribuée.

Cette classe fournit les fonctionnalités de base pour l'entraînement HyperPod sans points de contrôle en gérant les points de contrôle des NeMo modèles en mémoire, en validant la faisabilité de la restauration et en orchestrant le transfert des points de peer-to-peer contrôle entre les rangs sains et les rangs défaillants. Il élimine le besoin d'utiliser un disque I/O pendant la restauration, réduisant ainsi considérablement le temps moyen de restauration (MTTR).

Paramètres

Attributs

Méthodes

save_checkpoint(trainer)

Enregistrez le point de contrôle NeMo du modèle en mémoire pour une éventuelle restauration sans point de contrôle.

Paramètres :

Remarques :

delete_checkpoint()

Supprimez le point de contrôle en mémoire et effectuez des opérations de nettoyage.

Remarques :

try_checkpointless_load(trainer)

Essayez une restauration sans point de contrôle en chargeant l'état à partir des rangs des pairs.

Paramètres :

Retours :

Remarques :

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Déterminez si une restauration sans point de contrôle est possible pour le scénario de défaillance actuel.

Paramètres :

Retours :

Critères de validation :

store_rng_states()

Stockez tous les états du générateur de nombres aléatoires pour une restauration déterministe.

Remarques :

load_rng_states()

Restaurez tous les états RNG pour poursuivre la restauration déterministe.

Remarques :

maybe_offload_checkpoint()

Déchargez le point de contrôle du GPU vers la mémoire du processeur si le déchargement est activé.

Remarques :

Exemple

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

Validation : vérifie l'intégrité du point de contrôle à l'aide de sommes de contrôle (si activé)

Remarques

PEFTCheckpointDirecteur

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.PEFTCheckpointManager(  
    *args,  
    **kwargs)

Gère les points de contrôle pour le PEFT (Parameter-Efficient Fine-Tuning) avec une gestion séparée de la base et de l'adaptateur pour une restauration optimisée sans point de contrôle.

Ce gestionnaire de points de contrôle spécialisé permet CheckpointManager d'optimiser les flux de travail PEFT en séparant les poids du modèle de base des paramètres de l'adaptateur.

Paramètres

Hérite de tous les paramètres de CheckpointManager:

Attributs supplémentaires

Méthodes

maybe_save_base_model(trainer)

Enregistrez les poids du modèle de base une seule fois, en filtrant les paramètres de l'adaptateur.

Paramètres :

Remarques :

save_checkpoint(trainer)

Enregistrez le point de contrôle du modèle d'adaptateur NeMo PEFT en mémoire pour une éventuelle restauration sans point de contrôle.

Paramètres :

Remarques :

try_base_model_checkpointless_load(trainer)

Essayez de récupérer les poids du modèle de base PEFT sans point de contrôle en chargeant l'état à partir des rangs des pairs.

Paramètres :

Retours :

Remarques :

try_checkpointless_load(trainer)

Essayez de pondérer la récupération sans point de contrôle de l'adaptateur PEFT en chargeant l'état à partir des rangs des pairs.

Paramètres :

Retours :

Remarques :

is_adapter_key(key)

Vérifiez si la clé state dict appartient aux paramètres de l'adaptateur.

Paramètres :

Retours :

Logique de détection :

maybe_offload_checkpoint()

Déchargez les pondérations du modèle de base du GPU vers la mémoire du processeur.

Remarques :

Remarques

Exemple

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 d'usine permettant de créer et de gérer des compositions de composants abandonnées pour une tolérance aux pannes sans point de contrôle.

Cette classe utilitaire fournit des méthodes statiques pour créer, personnaliser et gérer les compositions de composants d'abandon utilisées lors de la gestion des pannes dans le cadre d'un entraînement sans HyperPod point de contrôle. Il simplifie la configuration des séquences d'interruption qui gèrent le nettoyage des composants de formation distribués, des chargeurs de données et des ressources spécifiques au framework lors de la reprise après défaillance.

Paramètres

Aucune (toutes les méthodes sont statiques)

Méthodes statiques

get_default_checkpointless_abort()

Obtenez l'instance abort compose par défaut contenant tous les composants d'abort standard.

Retours :

Composants par défaut :

create_custom_abort(abort_instances)

Créez une composition d'abandon personnalisée avec uniquement les instances d'abandon spécifiées.

Paramètres :

Retours :

Augmente :

override_abort(abort_compose, abort_type, new_abort)

Remplacez un composant d'abandon spécifique dans une instance de Compose par un nouveau composant.

Paramètres :

Retours :

Augmente :

Exemple

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

Remarques

CheckpointlessFinalizeCleanup

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()

Effectue un nettoyage complet après la détection d'un défaut afin de préparer la restauration en cours de processus lors d'une formation sans point de contrôle.

Ce gestionnaire de finalisation exécute des opérations de nettoyage spécifiques au framework, notamment l' Megatron/TransformerEngine abandon, le nettoyage DDP, le rechargement des modules et le nettoyage de la mémoire en détruisant les références aux composants d'entraînement. Cela garantit que l'environnement de formation est correctement réinitialisé pour une restauration en cours de processus réussie sans nécessiter l'arrêt complet du processus.

Paramètres

Aucune

Attributs

Méthodes

__call__(*a, **kw)

Exécutez des opérations de nettoyage complètes pour préparer la restauration en cours de processus.

Paramètres :

Opérations de nettoyage :

register_attributes(trainer)

Enregistrez l'instance de formation pour l'utiliser lors des opérations de nettoyage.

Paramètres :

Intégration avec 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(...)

Remarques

CheckpointlessMegatronStrategy

class hyperpod_checkpointless_training.nemo_plugins.megatron_strategy.CheckpointlessMegatronStrategy(*args, **kwargs)

NeMo Stratégie Megatron avec fonctionnalités intégrées de restauration sans point de contrôle pour un entraînement distribué tolérant aux pannes.

Notez que l'entraînement sans points de contrôle doit être au moins num_distributed_optimizer_instances égal à 2 pour qu'il y ait une réplication de l'optimiseur. La stratégie prend également en charge l'enregistrement des attributs essentiels et l'initialisation des groupes de processus.

Paramètres

Hérite de tous les paramètres de MegatronStrategy:

Attributs

Méthodes

setup(trainer)

Initialisez la stratégie et enregistrez les composants de tolérance aux pannes auprès du formateur.

Paramètres :

Opérations de configuration :

setup_distributed()

Initialisez le groupe de processus à l'aide d'un préfixe ou d' TCPStore une connexion sans racine.

load_model_state_dict(checkpoint, strict=True)

Chargez le modèle state dict avec compatibilité de restauration sans point de contrôle.

Paramètres :

get_wrapper()

Obtenez l'instance HPCall Wrapper pour la coordination de la tolérance aux pannes.

Retours :

is_peft()

Vérifiez si le PEFT (Parameter-Efficient Fine-Tuning) est activé dans la configuration d'entraînement en vérifiant les rappels PEFT

Retours :

teardown()

Remplacez le PyTorch démontage natif de Lightning pour déléguer le nettoyage aux gestionnaires d'abandon.

Exemple

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 qui intègre la NeMo formation au système de tolérance aux pannes de checkpointless Training.

Ce rappel gère le suivi des étapes, la sauvegarde des points de contrôle et la coordination des mises à jour des paramètres pour les capacités de restauration en cours de processus. Il constitue le principal point d'intégration entre les boucles d'entraînement PyTorch Lightning et les mécanismes de formation HyperPod sans point de contrôle, coordonnant les opérations de tolérance aux pannes tout au long du cycle de formation.

Paramètres

Attributs

Méthodes

get_wrapper_from_trainer(trainer)

Obtenez l'instance HPCall Wrapper auprès du formateur pour la coordination de la tolérance aux pannes.

Paramètres :

Retours :

on_train_batch_start(trainer, pl_module, batch, batch_idx, *args, **kwargs)

Appelé au début de chaque session de formation pour gérer le suivi des étapes et la récupération.

Paramètres :

on_train_batch_end(trainer, pl_module, outputs, batch, batch_idx)

Relâchez le verrou de mise à jour des paramètres à la fin de chaque lot d'apprentissage.

Paramètres :

Remarques :

get_peft_callback(trainer)

Récupérez le rappel PEFT dans la liste des rappels du formateur.

Paramètres :

Retours :

_try_adapter_checkpointless_restore(trainer, params_to_save)

Essayez de restaurer sans point de contrôle les paramètres de l'adaptateur PEFT.

Paramètres :

Remarques :

Exemple

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)

Gestion de mémoire

CheckpointlessCompatibleConnector

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()

PyTorch Connecteur Lightning Checkpoint qui intègre la restauration sans point de contrôle au chargement par point de contrôle traditionnel sur disque.

Ce connecteur étend celui de PyTorch Lightning _CheckpointConnector pour permettre une intégration parfaite entre la restauration sans point de contrôle et la restauration par point de contrôle standard. Il tente d'abord une restauration sans point de contrôle, puis revient au chargement par point de contrôle sur disque si la restauration sans point de contrôle n'est pas réalisable ou échoue.

Paramètres

Hérite de tous les paramètres de _ CheckpointConnector

Méthodes

resume_start(checkpoint_path=None)

Essayez de précharger le point de contrôle avec une priorité de restauration sans point de contrôle.

Paramètres :

resume_end()

Terminez le processus de chargement au point de contrôle et effectuez les opérations de post-chargement.

Remarques

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Prolonge NeMo la AutoResume configuration différée pour permettre la validation de la restauration sans point de contrôle avant la résolution du chemin du point de contrôle.

Cette classe met en œuvre une stratégie d'initialisation en deux phases qui permet la validation de la restauration sans point de contrôle avant de revenir au chargement par point de contrôle traditionnel sur disque. Il retarde la AutoResume configuration de manière conditionnelle pour empêcher la résolution prématurée de la trajectoire des points de contrôle, ce qui permet de valider dans CheckpointManager un premier temps si une restauration sans point de contrôle peer-to-peer est faisable.

Paramètres

Hérite de tous les paramètres de AutoResume

Méthodes

setup(trainer, model=None, force_setup=False)

Retardez la AutoResume configuration de manière conditionnelle pour permettre la validation de la restauration sans point de contrôle.

Paramètres :

Exemple

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

Remarques