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

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:

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

Guarda l'esempio per aggiungere funzionalità di formazione senza checkpointless ai codici.

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:

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_distributed_optimizer_instances, 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 totale 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 prevediamo 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).

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:

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 processo di rilevamento degli errori e di ripristino senza checkpoint:

Guida di riferimento alle API

wait_rank

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

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

Metodi

def __call__(self, fn)

Racchiude 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

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

Attributes

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:

def restart(term_ex)

Esegue il gestore di riavvio che include la finalizzazione, la raccolta dei rifiuti e i controlli di integrità.

Parametri:

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

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

Gestione degli errori di spegnimento e thread di monitoraggio.

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

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

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:

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

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 peer ranks.

Parametri:

Restituisce:

Note:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Determina se è possibile un ripristino senza checkpoint per lo scenario di errore corrente.

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

Note

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

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 il checkpoint del modello di adattatore NeMo PEFT in memoria per un potenziale ripristino senza checkpoint.

Parametri:

Note:

try_base_model_checkpointless_load(trainer)

Il modello base di Attempt PEFT valuta il ripristino senza checkpoint caricando lo stato dai ranghi dei peer rank.

Parametri:

Restituisce:

Note:

try_checkpointless_load(trainer)

L'adattatore PEFT di Attempt soppesa il ripristino senza checkpoint caricando lo stato dai ranghi dei colleghi.

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

Scarica 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 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:

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

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 per utilizzarla 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 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

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 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:

get_wrapper()

Ottieni l'istanza HPCall Wrapper per il coordinamento della tolleranza agli errori.

Restituisce:

is_peft()

Controlla se PEFT (Parameter-Efficient Fine-Tuning) è abilitato nella configurazione di addestramento verificando la presenza di callback PEFT

Restituisce:

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

Attributes

Metodi

get_wrapper_from_trainer(trainer)

Scarica l'istanza Wrapper dal trainer per il coordinamento della tolleranza agli errori. HPCall

Parametri:

Restituisce:

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:

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 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 _ CheckpointConnector

Metodi

resume_start(checkpoint_path=None)

Tentativo di precaricare il checkpoint con priorità di ripristino senza checkpointless.

Parametri:

resume_end()

Completa il processo di caricamento del checkpoint ed esegui le operazioni successive al caricamento.

Note

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:

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