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.

In-process récupération et entraînement sans point de contrôle

HyperPod la formation sans point de contrôle utilise la redondance des modèles pour permettre une formation tolérante 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 de 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'essentiel 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 point de contrôle. La formation Checkpointless sur Amazon SageMaker HyperPod prend en charge la restauration en cours de traitement. Cette interface API suit un format similaire à celui des API NVRx.

Concept - Bloc Re-Executable de code (RCB)

En cas de panne, les processus sains restent actifs, mais une partie du code doit être réexécutée pour récupérer les états d'entraînement et les piles Python. Un bloc de Re-executable code (RCB) est un segment de code spécifique qui s'exécute à nouveau lors de la restauration 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 restauration 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 pannes reçoit des notifications en cas de panne lors d'un entraînement sans point de contrôle. Ce contrôleur de défauts comprend les composants suivants :

Concept - Redondance des modèles

L'apprentissage de grands modèles nécessite généralement une taille parallèle de données suffisamment importante pour entraîner efficacement les modèles. Dans le 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 procéder à une réplication complète 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 partitionné sur l'ensemble du cluster, ce qui se traduira par une utilisation plus importante de la mémoire de l'appareil. La quantité de mémoire redondante varie en fonction des techniques de partitionnement des modèles spécifiques mises en œuvre par l'utilisateur. Les pondérations, les gradients et la mémoire d'activation du modèle de faible précision ne seront pas affectés, car ils sont partitionnés par le parallélisme des modèles. Le modèle principal de haute précision weights/gradients et les états de l'optimiseur seront affectés. L'ajout d'une réplique de modèle redondante augmente l'utilisation de la mémoire du périphérique d'environ l'équivalent d'un point de contrôle DCP.

Le sharding hybride divise les collectifs de l'ensemble des groupes DP en collectifs relativement plus restreints. Auparavant, il y avait une réduction de la dispersion et un rassemblement général dans l'ensemble du groupe DP. Après le sharding hybride, la réduction de la diffusion ne s'exécute que dans chaque réplique de modèle, et il y aura une réduction totale dans tous les groupes de répliques de modèles. L'ensemble se trouve également à l'intérieur de chaque réplique de modèle. Par conséquent, l'ensemble du volume de communication reste à peu près 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 répertorie les différents types de défaillances et les mécanismes de restauration associés. Checkpointless Training tente d'abord de remédier à la panne 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 Atomic Lock 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 la défaillance :

Cette stratégie garantit que les mises à jour de l'optimiseur terminées ne sont jamais supprimées, ce qui permet de réduire le temps de restauration après 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

rang d'attente

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'entraînement distribuées.

Cette fonction permet d'obtenir l'attribution de rang et les variables d'environnement correctes pour l'entraînement distribué. Il garantit que chaque processus dispose de la configuration appropriée pour son rôle dans la tâche de formation distribuée.

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

Emballage HP

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)

Enveloppe de fonctions Python qui permet de redémarrer un bloc de Re-executable code (RCB) lors d'un entraînement sans point de HyperPod contrôle.

Ce wrapper offre des capacité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'une approche de décorateur pour gérer les ressources globales tout au long du cycle de 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

HPCallWrapper

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 de HyperPod la barrière après avoir rencontré une exception de la part 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 processus provenant 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, la collecte des déchets et les contrôles de santé.

Paramètres :

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

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

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 fils de gestion des pannes et de surveillance.

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 de l'entraînement sans point de contrôle.

Ce bilan de santé se synchronise 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 GPU pour détecter tout problème susceptible d'empêcher la reprise de l'entraînement. Le bilan de santé est exécuté une fois que les groupes distribués ont été 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

HPAgentK8sAPIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Classe d'usine pour créer des instances HPAgentk8SAPI qui communiquent avec HyperPod l'infrastructure pour une coordination distribuée de la formation.

Cette fabrique fournit un moyen standardisé de créer et de configurer des objets HPAgentk8sapi qui gèrent la communication entre les processus d'entraînement et le plan de contrôle. HyperPod Il encapsule la création du client 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 HPAgentK8SAPI 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 restauration poste à poste pour garantir une tolérance aux pannes sans point de contrôle lors de la formation distribuée.

Ce cours fournit les fonctionnalités de base de l'entraînement HyperPod sans point 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 de points de contrôle pair à pair entre les rangs sains et les rangs défaillants. Il élimine le besoin de disque I/O lors de la restauration, ce qui réduit 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 depuis les 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é des points de contrôle à l'aide de sommes de contrôle (si elles sont activées)

Remarques

PEFTCheckpointManager

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

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

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 une restauration sans point de contrôle des pondérations du modèle de base PEFT en chargeant l'état à partir des rangs des pairs.

Paramètres :

Retours :

Remarques :

try_checkpointless_load(trainer)

Essayez une restauration sans point de contrôle des pondérations 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 poids 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 pour créer et gérer des compositions de composants abandonnés 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 de l'entraînement sans HyperPod point de contrôle. Il simplifie la configuration des séquences d'abandon 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 restauration après défaillance.

Paramètres

Aucune (toutes les méthodes sont statiques)

Méthodes statiques

get_default_checkpointless_abort()

Obtenez l'instance de composition d'abandon par défaut contenant tous les composants d'abandon 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 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 lors de la 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 des composants d'entraînement. Il 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.

Paramètres :

Opérations de nettoyage :

register_attributes(trainer)

Enregistrez l'instance d'entraînement à 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 la formation sans point de contrôle doit être num_distributed_optimizer_instances d'au moins 2 pour qu'il y ait 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 de TCPStore avec préfixe ou d'une connexion sans racine.

load_model_state_dict(checkpoint, strict=True)

Chargez le dict d'état du modèle avec compatibilité avec la restauration sans point de contrôle.

Paramètres :

get_wrapper()

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

Retours :

is_peft()

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

Retours :

teardown()

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

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)

Rappel éclair qui intègre l' NeMo entraînement 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 de la mise à jour des paramètres pour les fonctionnalités de restauration en cours de traitement. Il sert de point d'intégration principal entre les boucles d'entraînement PyTorch Lightning et les mécanismes d'entraînement 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' HPCallWrapper exemple 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 lot d'entraînement pour gérer le suivi des étapes et la reprise.

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'entraînement.

Paramètres :

Remarques :

get_peft_callback(trainer)

Récupérez le rappel PEFT à partir de la liste de rappels du formateur.

Paramètres :

Retours :

_try_adapter_checkpointless_restore(trainer, params_to_save)

Essayez une restauration sans point de contrôle pour 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 traditionnel des points de contrôle sur disque.

Ce connecteur étend PyTorch Lightning _CheckpointConnector pour permettre une intégration fluide entre la restauration sans point de contrôle et la restauration de point de contrôle standard. Il tente d'abord une restauration sans point de contrôle, puis revient au chargement des points de contrôle sur disque si la restauration sans point de contrôle n'est pas possible 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 configuration AutoResume avec une 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 de valider la restauration sans point de contrôle avant de revenir au chargement traditionnel des points de contrôle sur disque. Il retarde conditionnellement la AutoResume configuration pour éviter une résolution prématurée du chemin des points de contrôle, ce qui permet de valider d'abord si la CheckpointManager restauration peer-to-peer sans point de contrôle est faisable.

Paramètres

Hérite de tous les paramètres de AutoResume

Méthodes

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

Retardez conditionnellement la AutoResume configuration 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