Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

In-process Erholung und Training ohne Kontrollpunkte

HyperPod Checkpointless Training nutzt Modellredundanz, um ein fehlertolerantes Training zu ermöglichen. Das Kernprinzip besteht darin, dass Modell- und Optimiererstatus über mehrere Knotengruppen hinweg vollständig repliziert werden, wobei Gewichtungsaktualisierungen und Änderungen des Optimiererstatus innerhalb jeder Gruppe synchron repliziert werden. Wenn ein Fehler auftritt, schließen fehlerfreie Replikate ihre Optimierer-Schritte ab und übertragen die aktualisierten Status an die wiederherstellenden Replikate. model/optimizer

Dieser auf Modellredundanz basierende Ansatz ermöglicht mehrere Mechanismen zur Fehlerbehandlung:

Konfigurationen ohne Checkpoints

Hier ist der Kernausschnitt des Checkpointless-Trainings.

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

Sehen Sie sich das Beispiel an, um Codes mit Checkpointless-Trainingsfunktionen zu versehen.

Konzepte

In diesem Abschnitt werden Trainingskonzepte ohne Checkpointless vorgestellt. Das Checkpointless-Training bei Amazon SageMaker HyperPod unterstützt die prozessinterne Wiederherstellung. Diese API-Schnittstelle folgt einem ähnlichen Format wie die NVRx-APIs.

Konzept - Re-Executable Code Block (RCB)

Wenn ein Fehler auftritt, bleiben gesunde Prozesse am Leben, aber ein Teil des Codes muss erneut ausgeführt werden, um die Trainingszustände und Python-Stacks wiederherzustellen. Ein Re-executable Codeblock (RCB) ist ein bestimmtes Codesegment, das bei der Wiederherstellung nach einem Ausfall erneut ausgeführt wird. Im folgenden Beispiel umfasst der RCB das gesamte Trainingsskript (d. h. alles, was unter main () steht), was bedeutet, dass bei jeder Wiederherstellung nach einem Ausfall das Trainingsskript neu gestartet wird, während das speicherinterne Modell und der Optimierer beibehalten werden.

Konzept — Störungskontrolle

Ein Störungssteuermodul erhält Benachrichtigungen, wenn beim Training ohne Checkpoint Fehler auftreten. Dieser Fehlercontroller umfasst die folgenden Komponenten:

Konzept — Modellredundanz

Für das Training großer Modelle ist in der Regel eine ausreichend große parallele Datengröße erforderlich, um Modelle effizient trainieren zu können. Bei herkömmlicher Datenparallelität wie PyTorch DDP und Horovod wird das Modell vollständig repliziert. Fortgeschrittenere Techniken zur parallelen Nutzung von Daten wie DeepSpeed zERO Optimizer und FSDP unterstützen auch den hybriden Sharding-Modus, der das Sharding der Status innerhalb der Sharding-Gruppe und die vollständige Replikation über Replikationsgruppen hinweg ermöglicht. model/optimizer NeMo verfügt auch über diese hybride Sharding-Funktion über ein Argument num_distributed_optimizer_instances, das Redundanz ermöglicht.

Das Hinzufügen von Redundanz bedeutet jedoch, dass das Modell nicht vollständig über den gesamten Cluster verteilt wird, was zu einer höheren Gerätespeichernutzung führt. Die Menge des redundanten Speichers hängt von den spezifischen Sharding-Techniken des Modells ab, die vom Benutzer implementiert werden. Die Gewichtungen, Gradienten und der Aktivierungsspeicher von Modellen mit niedriger Genauigkeit sind davon nicht betroffen, da sie durch Modellparallelität aufgeteilt werden. Das hochpräzise Mastermodell weights/gradients und der Optimierer sind davon betroffen. Das Hinzufügen eines redundanten Modellreplikats erhöht die Speichernutzung des Geräts um ungefähr das Äquivalent einer DCP-Checkpoint-Größe.

Beim hybriden Sharding werden die Kollektive der gesamten DP-Gruppen in relativ kleinere Kollektive aufgeteilt. Zuvor gab es in der gesamten DP-Gruppe einen Reduce-Scatter und einen All-Gather. Nach dem Hybrid-Sharding läuft die Streureduzierung nur noch innerhalb der einzelnen Modellreplikate, und es findet eine Gesamtreduzierung über alle Modellreplikatgruppen hinweg statt. Der All-Gather wird auch in jedem Modellreplikat ausgeführt. Infolgedessen bleibt das gesamte Kommunikationsvolumen in etwa unverändert, aber Kollektive werden mit kleineren Gruppen ausgeführt, sodass wir eine bessere Latenz erwarten.

Konzept — Fehler- und Neustarttypen

In der folgenden Tabelle sind die verschiedenen Fehlertypen und die zugehörigen Wiederherstellungsmechanismen aufgeführt. Beim Checkpointless-Training wird zunächst versucht, den Ausfall durch eine prozessinterne Wiederherstellung zu beheben, gefolgt von einem Neustart auf Prozessebene. Nur bei einem katastrophalen Ausfall (z. B. wenn mehrere Knoten gleichzeitig ausfallen) wird auf einen Neustart auf Auftragsebene zurückgegriffen.

Konzept: Atomic Lock-Schutz für den Optimizer-Schritt

Die Modellausführung ist in drei Phasen unterteilt: Vorwärtsausbreitung, Rückwärtsausbreitung und Optimierer-Schritt. Das Wiederherstellungsverhalten variiert je nach Zeitpunkt des Fehlers:

Diese Strategie stellt sicher, dass abgeschlossene Optimizer-Updates niemals verworfen werden, was dazu beiträgt, die Zeit für die Fehlerbehebung zu verkürzen.

Ablaufdiagramm für das Training ohne Kontrollpunkte

Die folgenden Schritte beschreiben den Prozess der Fehlererkennung und der Wiederherstellung ohne Checkpoint:

API-Referenz

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Wartet auf Ranginformationen von HyperPod und aktualisiert dann die aktuelle Prozessumgebung mit verteilten Trainingsvariablen.

Diese Funktion ermittelt die korrekte Rangzuweisung und die Umgebungsvariablen für verteiltes Training. Sie stellt sicher, dass jeder Prozess die für seine Rolle in der verteilten Trainingsaufgabe geeignete Konfiguration erhält.

Parameter

Keine

Rückgabewerte

Keine

Behavior

Umgebungsvariablen

Die Funktion liest die folgenden Umgebungsvariablen:

Erhöht

Beispiel

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

Hinweise

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)

Python-Funktionswrapper, der Neustartfunktionen für einen Re-executable Codeblock (RCB) beim Training ohne Checkpoint ermöglicht. HyperPod

Dieser Wrapper bietet Funktionen für Fehlertoleranz und automatische Wiederherstellung, indem er die Trainingsausführung überwacht und Neustarts über verteilte Prozesse hinweg koordiniert, wenn Fehler auftreten. Es verwendet einen Kontextmanager-Ansatz anstelle eines Dekorators, um globale Ressourcen während des gesamten Trainingszyklus aufrechtzuerhalten.

Parameter

Methoden

def __call__(self, fn)

Umschließt eine Funktion, um Neustartfunktionen zu aktivieren.

Parameter:

Gibt zurück:

Beispiel

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

Hinweise

HPCallWrapper

class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)

Überwacht und verwaltet den Status eines Restart Code Blocks (RCB) während der Ausführung.

Diese Klasse behandelt den Lebenszyklus der RCB-Ausführung, einschließlich der Fehlererkennung, der Koordination mit anderen Rängen für Neustarts und Bereinigungsvorgänge. Es verwaltet die verteilte Synchronisation und gewährleistet eine konsistente Wiederherstellung aller Trainingsprozesse.

Parameter

Attribute

Methoden

def initialize_barrier()

Warten Sie auf die HyperPod Barrieren-Synchronisierung, nachdem Sie auf eine Ausnahme von RCB gestoßen sind.

def start_hp_fault_handling_thread()

Starten Sie den Fehlerbehandlungs-Thread zur Überwachung und Koordination von Ausfällen.

def handle_fn_exception(call_ex)

Verarbeiten Sie Ausnahmen aus der Ausführungsfunktion oder RCB.

Parameter:

def restart(term_ex)

Führt den Neustart-Handler aus, einschließlich Finalisierung, Garbage-Collection und Zustandsprüfungen.

Parameter:

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

Führt den RCB mit der richtigen Ausnahmebehandlung aus.

Parameter:

def run(fn, a, kw)

Hauptausführungsschleife, die Neustarts und die Barrierensynchronisierung verarbeitet.

Parameter:

def shutdown()

Threads zur Fehlerbehandlung und Überwachung von Threads herunterfahren.

Hinweise

CudaHealthCheck

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

Stellt sicher, dass sich der CUDA-Kontext für den aktuellen Prozess während der Trainingswiederherstellung ohne Checkpoint in einem gesunden Zustand befindet.

Diese Integritätsprüfung wird mit der GPU synchronisiert, um sicherzustellen, dass der CUDA-Kontext nach einem Trainingsfehler nicht beschädigt ist. Es führt GPU-Synchronisierungsvorgänge durch, um Probleme zu erkennen, die eine erfolgreiche Wiederaufnahme des Trainings verhindern könnten. Die Integritätsprüfung wird ausgeführt, nachdem verteilte Gruppen zerstört wurden und die Finalisierung abgeschlossen ist.

Parameter

Methoden

__call__(state, train_ex=None)

Führen Sie die CUDA-Integritätsprüfung aus, um die Integrität des GPU-Kontexts zu überprüfen.

Parameter:

Gibt zurück:

Erhöht:

Zustandserhaltung: Gibt den ursprünglichen Zustand und die Ausnahme unverändert zurück, wenn alle Prüfungen bestanden wurden

Beispiel

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

Hinweise

HPAgentK8sAPIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Factory-Klasse zur Erstellung von HPAgentk8SAPI-Instanzen, die mit der Infrastruktur für die verteilte Trainingskoordination kommunizieren HyperPod .

Diese Factory bietet eine standardisierte Methode zum Erstellen und Konfigurieren von HPAgentk8SAPI-Objekten, die die Kommunikation zwischen Trainingsprozessen und der Steuerungsebene verwalten. HyperPod Sie kapselt die Erstellung des zugrunde liegenden Socket-Clients und der API-Instanz und gewährleistet so eine konsistente Konfiguration in verschiedenen Teilen des Trainingssystems.

Methoden

__call__()

Erstellen Sie eine HPAgentk8SAPI-Instanz, die für die Kommunikation konfiguriert ist, und geben Sie sie zurück. HyperPod

Gibt Folgendes zurück:

Beispiel

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

Hinweise

CheckpointManager

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

Verwaltet speicherinterne Checkpoints und Peer-to-Peer-Recovery und sorgt so für eine fehlertolerante Fehlertoleranz ohne Checkpoints bei verteiltem Training.

Dieser Kurs bietet die Kernfunktionen für Training HyperPod ohne Checkpoints. Er verwaltet NeMo Modell-Checkpoints im Speicher, validiert die Durchführbarkeit der Wiederherstellung und orchestriert den Peer-to-Peer-Checkpoint-Transfer zwischen gesunden und ausgefallenen Rängen. Bei der Wiederherstellung ist keine Festplatte erforderlich, wodurch die mittlere I/O Wiederherstellungszeit (MTTR) erheblich reduziert wird.

Parameter

Attribute

Methoden

save_checkpoint(trainer)

Speichert den NeMo Modell-Checkpoint für eine mögliche Wiederherstellung ohne Checkpoint im Speicher.

Parameter:

Hinweise:

delete_checkpoint()

Löschen Sie den speicherinternen Checkpoint und führen Sie Bereinigungsvorgänge durch.

Hinweise:

try_checkpointless_load(trainer)

Versuchen Sie eine Wiederherstellung ohne Checkpoint, indem Sie den Status von Peer-Ranks laden.

Parameter:

Gibt zurück:

Hinweise:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Stellen Sie fest, ob eine Wiederherstellung ohne Checkpoint für das aktuelle Fehlerszenario möglich ist.

Parameter:

Gibt zurück:

Validierungskriterien:

store_rng_states()

Speichern Sie alle Zustandswerte des Zufallszahlengenerators für eine deterministische Wiederherstellung.

Hinweise:

load_rng_states()

Stellen Sie alle RNG-Zustände wieder her, um die deterministische Erholung fortzusetzen.

Hinweise:

maybe_offload_checkpoint()

Lädt den Checkpoint von der GPU in den CPU-Speicher aus, wenn Offload aktiviert ist.

Hinweise:

Beispiel

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

Validierung: Überprüft die Integrität von Checkpoints anhand von Prüfsummen (falls aktiviert)

Hinweise

PEFTCheckpointManager

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

Verwaltet Checkpoints für PEFT (Parameter-Efficient Fine-Tuning) mit separater Basis- und Adapterverwaltung für eine optimierte Wiederherstellung ohne Checkpoints.

Dieser spezialisierte Checkpoint-Manager wird erweitert, um PEFT-Workflows CheckpointManager zu optimieren, indem er die Gewichtungen des Basismodells von den Adapterparametern trennt.

Parameter

Erbt alle Parameter von: CheckpointManager

Zusätzliche Attribute

Methoden

maybe_save_base_model(trainer)

Speichern Sie die Gewichte des Basismodells einmal und filtern Sie die Adapterparameter heraus.

Parameter:

Hinweise:

save_checkpoint(trainer)

Speichern Sie den Checkpoint des NeMo PEFT-Adaptermodells im Speicher, um eine Wiederherstellung ohne Checkpoint zu ermöglichen.

Parameter:

Hinweise:

try_base_model_checkpointless_load(trainer)

Beim Versuch des PEFT-Basismodells wird die Wiederherstellung ohne Checkpoints gewichtet, indem der Status von Peer-Ranks geladen wird.

Parameter:

Gibt zurück:

Hinweise:

try_checkpointless_load(trainer)

Versuchen Sie, mithilfe des PEFT-Adapters die Wiederherstellung ohne Checkpoint zu gewichten, indem der Status von Peer-Ranks geladen wird.

Parameter:

Gibt zurück:

Hinweise:

is_adapter_key(key)

Prüfen Sie, ob der State-Dikt-Schlüssel zu den Adapterparametern gehört.

Parameter:

Gibt zurück:

Erkennungslogik:

maybe_offload_checkpoint()

Verlagert die Gewichte des Basismodells von der GPU in den CPU-Speicher.

Hinweise:

Hinweise

Beispiel

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

Factory-Klasse zur Erstellung und Verwaltung von Zusammenstellungen von Abbruchkomponenten im Sinne einer fehlerfreien Fehlertoleranz.

Diese Dienstprogrammklasse bietet statische Methoden zum Erstellen, Anpassen und Verwalten von Abbruchkomponentenkompositionen, die bei der Fehlerbehandlung beim Training ohne HyperPod Checkpoint verwendet werden. Sie vereinfacht die Konfiguration von Abbruchsequenzen, die die Bereinigung verteilter Trainingskomponenten, Datenlader und Framework-spezifischer Ressourcen bei der Wiederherstellung nach einem Ausfall übernehmen.

Parameter

Keine (alle Methoden sind statisch)

Statische Methoden

get_default_checkpointless_abort()

Ruft die Standard-Abort-Compose-Instanz ab, die alle Standard-Abbruchkomponenten enthält.

Gibt zurück:

Standardkomponenten:

create_custom_abort(abort_instances)

Erstellen Sie eine benutzerdefinierte Abbruchkomposition, die nur die angegebenen Abbruchinstanzen enthält.

Parameter:

Gibt zurück:

Erhöht:

override_abort(abort_compose, abort_type, new_abort)

Ersetzen Sie eine bestimmte Abbruchkomponente in einer Compose-Instanz durch eine neue Komponente.

Parameter:

Gibt zurück:

Erhöht:

Beispiel

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

Hinweise

CheckpointlessFinalizeCleanup

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()

Führt nach der Fehlererkennung eine umfassende Säuberung durch, um die Wiederherstellung während des Prozesses während des Trainings ohne Kontrollpunkte vorzubereiten.

Dieser Finalize-Handler führt Framework-spezifische Bereinigungsvorgänge aus, darunter Megatron/TransformerEngine Abbruch, DDP-Bereinigung, erneutes Laden von Modulen und Speicherbereinigung, indem Verweise auf Trainingskomponenten gelöscht werden. Er stellt sicher, dass die Trainingsumgebung für eine erfolgreiche prozessinterne Wiederherstellung ordnungsgemäß zurückgesetzt wird, ohne dass ein vollständiger Prozessabbruch erforderlich ist.

Parameter

Keine

Attribute

Methoden

__call__(*a, **kw)

Führen Sie umfassende Bereinigungsvorgänge aus, um die Wiederherstellung während des Prozesses vorzubereiten.

Parameter:

Aufräumarbeiten:

register_attributes(trainer)

Registrieren Sie die Trainer-Instanz für die Verwendung bei Bereinigungsvorgängen.

Parameter:

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

Hinweise

CheckpointlessMegatronStrategy

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

NeMo Megatron-Strategie mit integrierten Funktionen zur Wiederherstellung ohne Checkpoint für fehlertolerantes verteiltes Training.

Beachten Sie, dass beim Training ohne Checkpoint mindestens 2 Teilnehmer erforderlich sindnum_distributed_optimizer_instances, damit der Optimizer repliziert wird. Die Strategie kümmert sich auch um die Registrierung wichtiger Attribute und die Initialisierung von Prozessgruppen.

Parameter

Erbt alle Parameter von: MegatronStrategy

Attribute

Methoden

setup(trainer)

Initialisieren Sie die Strategie und registrieren Sie die Fehlertoleranzkomponenten beim Trainer.

Parameter:

Vorgänge einrichten:

setup_distributed()

Initialisieren Sie die Prozessgruppe entweder mit TCPStore mit Präfix oder mit einer Rootless-Verbindung.

load_model_state_dict(checkpoint, strict=True)

Laden Sie das Modellstatusdiktat mit Recovery-Kompatibilität ohne Checkpoint.

Parameter:

get_wrapper()

Ruft die HPCallWrapper Instanz für die Fehlertoleranzkoordination ab.

Gibt zurück:

is_peft()

Überprüfe, ob PEFT (Parameter-Efficient Fine-Tuning) in der Trainingskonfiguration aktiviert ist, indem du nach PEFT-Callbacks suchst

Kehrt zurück:

teardown()

Überschreiben Sie den nativen PyTorch Lightning-Teardown, um die Bereinigung an Abbruchhandler zu delegieren.

Beispiel

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-Rückruf, der das NeMo Training in das Fehlertoleranzsystem von Checkpointless Training integriert.

Dieser Callback verwaltet die Schrittverfolgung, das Speichern von Prüfpunkten und die Koordination von Parameteraktualisierungen für die prozessinterne Wiederherstellung. Er dient als primärer Integrationspunkt zwischen PyTorch Lightning-Trainingsschleifen und HyperPod Checkpointless-Trainingsmechanismen und koordiniert Fehlertoleranzmaßnahmen während des gesamten Trainingszyklus.

Parameter

Attribute

Methoden

get_wrapper_from_trainer(trainer)

Ruft die Instanz für die Fehlertoleranzkoordination vom Trainer ab. HPCallWrapper

Parameter:

Gibt zurück:

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

Wird zu Beginn jedes Trainingsbatches aufgerufen, um die Schrittverfolgung und Wiederherstellung zu verwalten.

Parameter:

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

Heben Sie die Sperre für die Parameter-Aktualisierung am Ende jedes Trainingsbatches auf.

Parameter:

Hinweise:

get_peft_callback(trainer)

Ruft den PEFT-Callback aus der Callback-Liste des Trainers ab.

Parameter:

Gibt zurück:

_try_adapter_checkpointless_restore(trainer, params_to_save)

Versuchen Sie, PEFT-Adapterparameter ohne Checkpoint wiederherzustellen.

Parameter:

Hinweise:

Beispiel

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)

Arbeitsspeicher-Verwaltung

CheckpointlessCompatibleConnector

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()

PyTorch Lightning-Checkpoint-Connector, der die Wiederherstellung ohne Checkpoint in das herkömmliche, festplattenbasierte Checkpoint-Laden integriert.

Dieser Connector erweitert den von PyTorch Lightning _CheckpointConnector um eine nahtlose Integration zwischen der Wiederherstellung ohne Checkpoint und der standardmäßigen Checkpoint-Wiederherstellung. Er versucht zunächst, eine Wiederherstellung ohne Checkpoint durchzuführen, und greift dann auf festplattenbasiertes Checkpoint-Laden zurück, falls eine Wiederherstellung ohne Checkpoint nicht durchführbar ist oder fehlschlägt.

Parameter

Erbt alle Parameter von _ CheckpointConnector

Methoden

resume_start(checkpoint_path=None)

Versuchen Sie, den Checkpoint mit einer Wiederherstellungspriorität ohne Checkpoint vorab zu laden.

Parameter:

resume_end()

Schließen Sie den Checkpoint-Ladevorgang ab und führen Sie Operationen nach dem Laden durch.

Hinweise

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Erweitert um NeMo eine AutoResume verzögerte Einrichtung, um eine Überprüfung der Wiederherstellung ohne Checkpoint vor der Auflösung des Checkpoint-Pfads zu ermöglichen.

Diese Klasse implementiert eine zweiphasige Initialisierungsstrategie, die eine Überprüfung der Wiederherstellung ohne Checkpoint ermöglicht, bevor auf das herkömmliche, festplattenbasierte Checkpoint-Laden zurückgegriffen wird. Das AutoResume Setup wird bedingt verzögert, um eine vorzeitige Auflösung des Checkpoint-Pfads zu verhindern. So kann zunächst überprüft werden, ob eine Peer-to-Peer-Wiederherstellung ohne Checkpoint CheckpointManager durchführbar ist.

Parameter

Erbt alle Parameter von AutoResume

Methoden

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

Verzögern Sie das AutoResume Setup unter bestimmten Bedingungen, um eine Überprüfung der Wiederherstellung ohne Prüfpunkte zu ermöglichen.

Parameter:

Beispiel

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

Hinweise