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à.

In-process recupero e allenamento senza checkpoint

HyperPod checkpointless training utilizza la ridondanza del modello per consentire un addestramento tollerante ai guasti. Il principio fondamentale è che gli stati del modello e dell'ottimizzatore sono completamente replicati su più gruppi di nodi, con gli aggiornamenti del peso e le modifiche allo 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:

Configurazioni senza controlli

Ecco lo snippet principale di checkpointless training.

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

Guarda l'esempio per aggiungere funzionalità di addestramento senza checkpoint ai codici.

Concetti

Questa sezione introduce i concetti di formazione senza checkpoint. La formazione Checkpointless su Amazon supporta il ripristino in corso. SageMaker HyperPod Questa interfaccia API segue un formato simile a quello delle API NVRx.

Concetto: Re-Executable Code Block (RCB)

Quando si verifica un errore, i processi integri rimangono attivi, ma una parte del codice deve essere rieseguita per ripristinare gli stati di addestramento e gli stack di Python. Un Re-executable Code Block (RCB) è un segmento di codice specifico che viene rieseguito 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 gli stati del modello in memoria e dell'ottimizzatore.

Concetto - Controllo dei guasti

Un modulo di controllo dei guasti riceve notifiche quando si verificano guasti durante l'addestramento senza checkpoint. Questo controller di guasto include i seguenti componenti:

Concetto: ridondanza del modello

L'addestramento di 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 di parallelismo frammentato dei dati più avanzate, come DeepSpeed Zero Optimizer e FSDP, supportano anche la modalità sharding ibrido, che consente lo sharding degli stati all'interno del gruppo di sharding e la replica completa tra i gruppi di replica. model/optimizer NeMo dispone anche di questa funzionalità di sharding ibrido tramite un argomento num_distributed_optimizer_instances, che consente la ridondanza.

Tuttavia, l'aggiunta della ridondanza indica che il modello non sarà completamente suddiviso in partizioni nell'intero 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 saranno influenzati, poiché vengono suddivisi tramite il parallelismo del modello. Gli stati del modello master ad alta precisione e dell'ottimizzatore saranno influenzati. weights/gradients L'aggiunta di una replica ridondante del modello aumenta l'utilizzo della memoria del dispositivo di circa l'equivalente di una dimensione di checkpoint DCP.

Lo sharding ibrido suddivide i collettivi degli interi gruppi DP in gruppi relativamente più piccoli. In precedenza, c'era una riduzione della dispersione e una raccolta completa in tutto il gruppo DP. Dopo lo sharding ibrido, il reduce-scatter viene eseguito solo all'interno di ogni replica del modello e ci sarà una riduzione totale tra i gruppi di repliche del modello. L'all-ather viene eseguito anche all'interno di ogni replica del modello. Di conseguenza, l'intero volume delle comunicazioni rimane pressoché invariato, ma i collettivi funzionano con gruppi più piccoli, quindi prevediamo una latenza migliore.

Concetto: tipi di errore e riavvio

La tabella seguente registra 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 procede al riavvio a livello di processo solo in caso di guasto catastrofico (ad esempio, più nodi si guastano contemporaneamente).

Concetto: protezione con blocco atomico 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:

Questa strategia garantisce che gli aggiornamenti completati dell'ottimizzatore non vengano mai scartati, contribuendo a ridurre i tempi di ripristino dei guasti.

Diagramma del flusso di allenamento Checkpointless

I passaggi seguenti descrivono il rilevamento degli errori e il processo di ripristino senza checkpoint:

Guida di riferimento alle API

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Attende e recupera le informazioni sui ranghi da HyperPod, quindi aggiorna l'ambiente di processo corrente con variabili di addestramento distribuite.

Questa funzione ottiene la corretta assegnazione dei ranghi e le variabili di ambiente per la formazione distribuita. Assicura che ogni processo ottenga la configurazione appropriata per il suo ruolo nel processo di formazione distribuito.

Parametri

Nessuno

Valori restituiti

Nessuno

Comportamento

Variabili di ambiente

La funzione legge le seguenti variabili di ambiente:

Aumenta

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

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 di un Re-executable Code Block (RCB) durante l'addestramento senza checkpoint. HyperPod

Questo wrapper offre funzionalità di tolleranza ai guasti e ripristino automatico monitorando l'esecuzione della formazione e coordinando i riavvii tra i processi distribuiti in caso di guasti. Utilizza un approccio di gestione del contesto piuttosto che un decoratore per mantenere le risorse globali durante tutto il ciclo di vita della formazione.

Parametri

Metodi

def __call__(self, fn)

Include una funzione per abilitare le funzionalità di riavvio.

Parametri:

Restituisce:

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

HPCallWrapper

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

Attributes

Metodi

def initialize_barrier()

Attendi la sincronizzazione HyperPod della barriera dopo aver riscontrato un'eccezione da RCB.

def start_hp_fault_handling_thread()

Avvia il thread di gestione dei guasti per il monitoraggio e il coordinamento dei guasti.

def handle_fn_exception(call_ex)

Elabora le eccezioni dalla funzione di esecuzione o dall'RCB.

Parametri:

def restart(term_ex)

Esegue il gestore di riavvio, inclusi finalizzazione, garbage collection e controlli di integrità.

Parametri:

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

Esegue l'RCB con una corretta gestione delle eccezioni.

Parametri:

def run(fn, a, kw)

Ciclo di esecuzione principale che gestisce i riavvii e la sincronizzazione delle barriere.

Parametri:

def shutdown()

Thread di gestione e monitoraggio dei guasti di spegnimento.

Note

CudaHealthCheck

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

Assicura che il contesto CUDA per il processo corrente sia integro durante il recupero dell'allenamento senza interruzioni.

Questo controllo dello stato si sincronizza con la GPU per verificare che il contesto CUDA non sia danneggiato dopo un errore di addestramento. Esegue operazioni di sincronizzazione della GPU per rilevare eventuali problemi che potrebbero impedire una corretta ripresa dell'allenamento. Il controllo dello stato viene eseguito dopo la distruzione dei gruppi distribuiti e il completamento della finalizzazione.

Parametri

Metodi

__call__(state, train_ex=None)

Esegui il controllo dello stato di salute CUDA per verificare l'integrità del contesto della GPU.

Parametri:

Restituisce:

Aumenta:

Conservazione dello stato: restituisce lo stato originale e l'eccezione 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

HPAgentK8sAPIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Classe di fabbrica per la creazione di istanze HPAgenTK8SAPI che comunicano con l'infrastruttura per il coordinamento distribuito della formazione. HyperPod

Questa fabbrica fornisce un modo standardizzato per creare e configurare oggetti HPAgentK8SAPI 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 restituisce un'istanza HPAgentK8SAPI configurata per la comunicazione. HyperPod

Restituisce:

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

CheckpointManager

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

Gestisce i checkpoint in memoria e il ripristino peer-to-peer per una tolleranza agli errori senza checkpoint nella formazione distribuita.

Questa classe fornisce le funzionalità di base per l'addestramento HyperPod senza checkpoint gestendo i checkpoint del NeMo modello in memoria, convalidando la fattibilità del ripristino e orchestrando il trasferimento peer-to-peer dei checkpoint tra ranghi integri e non riusciti. Elimina la necessità di utilizzare un disco durante il ripristino, riducendo significativamente il tempo medio di ripristino (MTTR). I/O

Parametri

Attributes

Metodi

save_checkpoint(trainer)

Salva il checkpoint del NeMo modello in memoria per un potenziale ripristino senza checkpoint.

Parametri:

Note:

delete_checkpoint()

Elimina il checkpoint in memoria ed esegui le operazioni di pulizia.

Note:

try_checkpointless_load(trainer)

Tenta il ripristino senza checkpoint caricando lo stato dai ranghi dei pari.

Parametri:

Restituisce:

Note:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Determina se è possibile un ripristino senza checkpoint per l'attuale scenario di errore.

Parametri:

Restituisce:

Criteri di convalida:

store_rng_states()

Memorizza tutti gli stati del generatore di numeri casuali per il ripristino deterministico.

Note:

load_rng_states()

Ripristina tutti gli stati RNG per la continuazione deterministica del recupero.

Note:

maybe_offload_checkpoint()

Sposta il checkpoint dalla GPU alla memoria della CPU se l'offload è abilitato.

Note:

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à dei checkpoint utilizzando i checksum (se abilitati)

Note

PEFTCheckpointManager

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

Gestisce i checkpoint per PEFT (Parameter-Efficient Fine-Tuning) con una gestione separata della base e dell'adattatore per un ripristino ottimizzato senza checkpoint.

Questo gestore di checkpoint specializzato consente di ottimizzare i flussi CheckpointManager di lavoro PEFT separando i pesi del modello base dai parametri dell'adattatore.

Parametri

Eredita tutti i parametri da: CheckpointManager

Attributi aggiuntivi

Metodi

maybe_save_base_model(trainer)

Salva i pesi del modello base una volta, filtrando i parametri dell'adattatore.

Parametri:

Note:

save_checkpoint(trainer)

Salva in memoria il checkpoint del modello dell'adattatore NeMo PEFT per un potenziale ripristino senza checkpoint.

Parametri:

Note:

try_base_model_checkpointless_load(trainer)

Prova il ripristino senza checkpoint del modello base PEFT caricando lo stato dai ranghi dei pari.

Parametri:

Restituisce:

Note:

try_checkpointless_load(trainer)

Prova il ripristino senza checkpoint dei pesi dell'adattatore PEFT caricando lo stato dai ranghi dei pari.

Parametri:

Restituisce:

Note:

is_adapter_key(key)

Controlla se la chiave State Dict appartiene ai parametri dell'adattatore.

Parametri:

Restituisce:

Logica di rilevamento:

maybe_offload_checkpoint()

Sposta i pesi del modello base dalla GPU alla memoria della CPU.

Note:

Note

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 di fabbrica per la creazione e la gestione di composizioni di componenti di interruzione per una tolleranza agli errori senza controlli.

Questa classe di utilità fornisce metodi statici per creare, personalizzare e gestire le composizioni di componenti di interruzione utilizzate durante la gestione dei guasti nell'addestramento senza controlli. HyperPod Semplifica la configurazione delle sequenze di interruzione che gestiscono la pulizia dei componenti di training distribuiti, dei caricatori di dati e delle risorse specifiche del framework durante il ripristino in caso di guasto.

Parametri

Nessuno (tutti i metodi sono statici)

Metodi statici

get_default_checkpointless_abort()

Ottieni l'istanza abort compose predefinita contenente tutti i componenti abort standard.

Restituisce:

Componenti predefiniti:

create_custom_abort(abort_instances)

Crea una composizione di interruzione personalizzata con solo le istanze di interruzione specificate.

Parametri:

Restituisce:

Aumenta:

override_abort(abort_compose, abort_type, new_abort)

Sostituisci un componente di interruzione specifico in un'istanza di Compose con un nuovo componente.

Parametri:

Restituisce:

Aumenta:

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

CheckpointlessFinalizeCleanup

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()

Esegue una pulizia completa dopo il rilevamento dei guasti per prepararsi al ripristino durante il processo durante la formazione senza controlli.

Questo gestore di finalizzazione esegue operazioni di pulizia specifiche del framework, tra cui l' Megatron/TransformerEngine interruzione, la pulizia DDP, il ricaricamento dei moduli e la pulizia della memoria distruggendo i riferimenti ai componenti di addestramento. Assicura che l'ambiente di formazione sia ripristinato correttamente per un corretto ripristino durante il processo senza richiedere l'interruzione completa del processo.

Parametri

Nessuno

Attributes

Metodi

__call__(*a, **kw)

Esegui operazioni di pulizia complete per la preparazione del ripristino durante il processo.

Parametri:

Operazioni di pulizia:

register_attributes(trainer)

Registra l'istanza del trainer da utilizzare durante le operazioni di pulizia.

Parametri:

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

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 tollerante ai guasti.

Tieni presente che l'addestramento senza checkpoint deve essere composto da almeno 2 persone 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.

Parametri

Eredita tutti i parametri da: MegatronStrategy

Attributes

Metodi

setup(trainer)

Inizializza la strategia e registra i componenti di tolleranza ai guasti con il trainer.

Parametri:

Operazioni di configurazione:

setup_distributed()

Inizializza il gruppo di processi utilizzando TCPStore con prefisso o connessione rootless.

load_model_state_dict(checkpoint, strict=True)

Carica il dict sullo stato del modello con compatibilità con il ripristino senza checkpoint.

Parametri:

get_wrapper()

Ottieni l' HPCallWrapper istanza per il coordinamento della tolleranza ai guasti.

Restituisce:

is_peft()

Controlla se PEFT (Parameter-Efficient Fine-Tuning) è abilitato nella configurazione di addestramento controllando i callback PEFT

Restituisce:

teardown()

Sostituisci lo smontaggio nativo di PyTorch Lightning per delegare la pulizia ai gestori delle interruzioni.

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)

Richiamata Lightning che integra la formazione con il sistema di tolleranza ai guasti di checkpointless training. NeMo

Questo callback gestisce il monitoraggio dei passaggi, il salvataggio dei checkpoint e il coordinamento dell'aggiornamento dei parametri per le funzionalità di ripristino in corso. Funge da punto di integrazione principale tra i cicli di formazione PyTorch Lightning e i meccanismi di formazione HyperPod senza controlli, coordinando le operazioni di tolleranza ai guasti durante l'intero ciclo di vita della formazione.

Parametri

Attributes

Metodi

get_wrapper_from_trainer(trainer)

Richiedete l'istanza dal HPCallWrapper trainer per il coordinamento della tolleranza ai guasti.

Parametri:

Restituisce:

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

Richiamata all'inizio di ogni batch di formazione per gestire il monitoraggio e il ripristino delle fasi.

Parametri:

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:

Note:

get_peft_callback(trainer)

Recupera il callback PEFT dall'elenco dei callback del trainer.

Parametri:

Restituisce:

_try_adapter_checkpointless_restore(trainer, params_to_save)

Tenta il ripristino senza checkpoint dei parametri dell'adattatore PEFT.

Parametri:

Note:

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

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 _CheckpointConnector e il ripristino dei checkpoint standard. Tenta prima il ripristino senza checkpoint, quindi ritorna al caricamento del checkpoint basato su disco se il ripristino senza checkpoint non è fattibile o fallisce.

Parametri

Eredita tutti i parametri da _ CheckpointConnector

Metodi

resume_start(checkpoint_path=None)

Tenta di precaricare il checkpoint con priorità di ripristino senza checkpoint.

Parametri:

resume_end()

Completa il processo di caricamento del checkpoint ed esegui le operazioni di post-caricamento.

Note

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Si estende AutoResume con NeMo una configurazione ritardata per consentire la convalida del ripristino senza checkpoint prima della risoluzione del percorso del 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 condizionatamente la AutoResume configurazione per evitare una risoluzione prematura del percorso dei checkpoint, consentendo di verificare innanzitutto se è possibile un ripristino peer-to-peer senza checkpoint. CheckpointManager

Parametri

Eredita tutti i parametri da AutoResume

Metodi

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

Ritarda condizionatamente la AutoResume configurazione per consentire la convalida del ripristino senza checkpoint.

Parametri:

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