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.

Prozessbegleitende Wiederherstellung und Training ohne Kontrollpunkte

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

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

Konfigurationen ohne Checkpoint

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 Trainingsfunktionen ohne Checkpoint hinzuzufügen.

Konzepte

In diesem Abschnitt werden Trainingskonzepte ohne Checkpoint vorgestellt. Checkpointless-Schulungen bei Amazon SageMaker HyperPod unterstützen die Wiederherstellung während des Prozesses. Diese API-Schnittstelle folgt einem ähnlichen Format wie die. NVRx APIs

Konzept — Wiederausführbarer Codeblock (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 wiederausführbarer Codeblock (RCB) ist ein bestimmtes Codesegment, das bei der Wiederherstellung nach einem Fehler 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 Fehler das Trainingsskript neu gestartet wird, wobei das In-Memory-Modell und der Optimizer-Status beibehalten werden.

Konzept — Fehlerkontrolle

Ein Fault Controller-Modul erhält Benachrichtigungen, wenn beim Training ohne Checkpoint Fehler auftreten. Dieser Fehlercontroller umfasst die folgenden Komponenten:

Konzept — Modellredundanz

Das Training großer Modelle erfordert normalerweise eine ausreichend große Datenparallelgröße, um Modelle effizient zu trainieren. Bei herkömmlicher Datenparallelität wie PyTorch DDP und Horovod wird das Modell vollständig repliziert. Fortgeschrittenere Techniken der Shard-Datenparallelität wie DeepSpeed ZerO Optimizer und FSDP unterstützen auch den Hybrid-Sharding-Modus, der das Sharding der Status innerhalb der Sharding-Gruppe und die vollständige Replikation zwischen Replikationsgruppen ermöglicht. model/optimizer NeMo verfügt über diese Hybrid-Sharding-Funktion auch über ein Argument num_distributed_optimizer_instances, das Redundanz ermöglicht.

Das Hinzufügen von Redundanz bedeutet jedoch, dass das Modell nicht vollständig auf den gesamten Cluster verteilt wird, was zu einer höheren Speicherauslastung des Geräts führt. Die Menge des redundanten Speichers hängt von den spezifischen Model-Sharding-Techniken ab, die der Benutzer implementiert. Die Gewichtungen, Gradienten und der Aktivierungsspeicher des Modells mit niedriger Genauigkeit werden nicht beeinträchtigt, da sie aufgrund der Modellparallelität fragmentiert werden. Das hochpräzise Master-Modell weights/gradients und der Optimizer-Status werden davon beeinflusst. Durch das Hinzufügen eines redundanten Modellreplikats erhöht sich die Speicherauslastung des Geräts um etwa die Größe eines DCP-Checkpoints.

Beim Hybrid-Sharding werden die Kollektive der gesamten DP-Gruppen in relativ kleinere Kollektive aufgeteilt. Bisher gab es in der gesamten DP-Gruppe ein Prinzip zur Reduzierung der Streuung und ein All-Gathering. Nach dem Hybrid-Sharding läuft die Methode zur Reduzierung der Streuung nur innerhalb der einzelnen Modellreplikate, und es wird eine All-Reduce-Methode für alle Modellreplikatgruppen geben. Das All-Gather-System wird auch innerhalb jeder Modellreplikation ausgeführt. Dadurch bleibt das gesamte Kommunikationsvolumen in etwa unverändert, aber die Kollektive arbeiten mit kleineren Gruppen, sodass wir mit einer besseren Latenz rechnen.

Konzept — Fehler- und Neustarttypen

In der folgenden Tabelle sind verschiedene Fehlertypen und zugehörige Wiederherstellungsmechanismen aufgeführt. Beim Checkpointless-Training wird zunächst versucht, Fehler mithilfe einer prozessinternen Wiederherstellung zu beheben, gefolgt von einem Neustart auf Prozessebene. Nur im Falle eines schwerwiegenden Fehlers (z. B. wenn mehrere Knoten gleichzeitig ausfallen), wird auf einen Neustart auf Jobebene 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 Optimierungsschritt. Das Wiederherstellungsverhalten hängt vom Zeitpunkt des Fehlers ab:

Diese Strategie stellt sicher, dass abgeschlossene Optimizer-Updates niemals verworfen werden, wodurch die Zeit für die Fehlerbehebung reduziert wird.

Ablaufdiagramm des Checkpointless-Trainings

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

API-Referenz

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Wartet auf Ranginformationen von der aktuellen Prozessumgebung HyperPod, ruft sie ab und aktualisiert sie anschließend mit verteilten Trainingsvariablen.

Diese Funktion ruft die richtigen Rangzuweisungen und Umgebungsvariablen für verteiltes Training ab. Sie stellt sicher, dass jeder Prozess die passende Konfiguration für seine Rolle im verteilten Trainingsjob 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 reausführbaren Codeblock (RCB) beim Checkpointless-Training ermöglicht. HyperPod

Dieser Wrapper bietet Funktionen für Fehlertoleranz und automatische Wiederherstellung, indem er die Trainingsausführung überwacht und bei Ausfällen Neustarts zwischen verteilten Prozessen koordiniert. Er verwendet eher einen Context-Manager-Ansatz als einen Dekorateur, um die globalen Ressourcen während des gesamten Schulungszyklus aufrechtzuerhalten.

Parameter

Methoden

def __call__(self, fn)

Schließt eine Funktion ein, 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-Codeblocks (RCB) während der Ausführung.

Diese Klasse befasst sich mit dem Lebenszyklus der RCB-Ausführung, einschließlich der Fehlererkennung, der Koordination mit anderen Rängen bei Neustarts und Bereinigungsvorgängen. Es verwaltet die verteilte Synchronisation und sorgt für eine konsistente Erholung in allen Trainingsprozessen.

Parameter

Attribute

Methoden

def initialize_barrier()

Warten Sie auf die HyperPod Barrierensynchronisierung, 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 Fehlern.

def handle_fn_exception(call_ex)

Verarbeiten Sie Ausnahmen von der Ausführungsfunktion oder vom RCB.

Parameter:

def restart(term_ex)

Führt den Neustart-Handler aus, einschließlich Finalisierung, Garbage-Collection und Integritätsprü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 Barrierensynchronisierung verarbeitet.

Parameter:

def shutdown()

Threads zur Fehlerbehandlung und Überwachung 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 fehlerfreien 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 die verteilten Gruppen gelöscht 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:

Beibehaltung des Zustands: Gibt den ursprünglichen Status 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

HPAgentK8s APIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Factory-Klasse zum Erstellen von HPAgent K8SAPI-Instanzen, die mit der HyperPod Infrastruktur kommunizieren, um die Trainingskoordination auf verteilter Ebene zu gewährleisten.

Diese Factory bietet eine standardisierte Methode zur Erstellung und Konfiguration von HPAgent K8sAPI-Objekten, die die Kommunikation zwischen Trainingsprozessen und der Steuerungsebene regeln. HyperPod Es 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 für die Kommunikation konfigurierte HPAgent K8SAPI-Instanz und geben Sie sie zurück. HyperPod

Gibt 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 die Checkpoints und die peer-to-peer Wiederherstellung im Speicher und sorgt so für Fehlertoleranz ohne Checkpoints bei verteilten Schulungen.

Diese Klasse bietet die Kernfunktionen für das Training HyperPod ohne Checkpoints, indem sie NeMo Modell-Checkpoints im Speicher verwaltet, die Durchführbarkeit der Wiederherstellung überprüft und die Checkpoint-Übertragung zwischen fehlerfreien und ausgefallenen Rängen orchestriert peer-to-peer. Dadurch entfällt die Notwendigkeit einer Festplatte I/O bei der Wiederherstellung, wodurch die mittlere Wiederherstellungszeit (MTTR) erheblich reduziert wird.

Parameter

Attribute

Methoden

save_checkpoint(trainer)

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

Parameter:

Hinweise:

delete_checkpoint()

Löschen Sie den In-Memory-Checkpoint und führen Sie Bereinigungsvorgänge durch.

Hinweise:

try_checkpointless_load(trainer)

Versuchen Sie eine Wiederherstellung ohne Checkpoint, indem Sie den Status aus Peer-Rängen 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()

Speichert alle Zustände des Zufallszahlengenerators für die deterministische Wiederherstellung.

Hinweise:

load_rng_states()

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

Hinweise:

maybe_offload_checkpoint()

Wenn Offload aktiviert ist, wird der Checkpoint von der GPU auf den CPU-Speicher verlagert.

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 Checkpoint-Integrität 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 ermöglicht die Optimierung von PEFT-Workflows CheckpointManager , indem er die Gewichtung des Basismodells von den Adapterparametern trennt.

Parameter

Erbt alle Parameter von: CheckpointManager

Zusätzliche Attribute

Methoden

maybe_save_base_model(trainer)

Speichert einmal die Gewichte des Basismodells und filtert dabei die Adapterparameter heraus.

Parameter:

Hinweise:

save_checkpoint(trainer)

Speichern Sie den Prüfpunkt des NeMo PEFT-Adaptermodells im Speicher für eine mögliche Wiederherstellung ohne Checkpoint.

Parameter:

Hinweise:

try_base_model_checkpointless_load(trainer)

Das PEFT-Basismodell versucht, die Wiederherstellung ohne Checkpoint zu gewichten, indem der Status aus Peer-Rängen geladen wird.

Parameter:

Gibt zurück:

Hinweise:

try_checkpointless_load(trainer)

Der PEFT-Adapter versucht, die Wiederherstellung ohne Checkpoint zu gewichten, indem er den Status aus Peer-Rängen lädt.

Parameter:

Gibt zurück:

Hinweise:

is_adapter_key(key)

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

Parameter:

Gibt zurück:

Erkennungslogik:

maybe_offload_checkpoint()

Verlagert die Gewichte des Basismodells von der GPU auf 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 für die Erstellung und Verwaltung von Komponentenzusammensetzungen bei Abbruch, um eine fehlerfreie Fehlertoleranz zu gewährleisten.

Diese Utility-Klasse bietet statische Methoden zum Erstellen, Anpassen und Verwalten von Zusammenstellungen von Abbruchkomponenten, die bei der Fehlerbehandlung beim Checkpointless-Training verwendet werden. HyperPod Sie vereinfacht die Konfiguration von Abbruchsequenzen, mit denen verteilte Trainingskomponenten, Datenlader und Framework-spezifische Ressourcen bei der Wiederherstellung nach einem Ausfall bereinigt werden.

Parameter

Keine (alle Methoden sind statisch)

Statische Methoden

get_default_checkpointless_abort()

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

Gibt zurück:

Standardkomponenten:

create_custom_abort(abort_instances)

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

Parameter:

Gibt zurück:

Löst aus:

override_abort(abort_compose, abort_type, new_abort)

Ersetzt 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 einer Schulung ohne Kontrollpunkte vorzubereiten.

Dieser Finalize-Handler führt Framework-spezifische Bereinigungsvorgänge wie Megatron/TransformerEngine Abbruch, DDP-Bereinigung, erneutes Laden von Modulen und Speicherbereinigung durch, indem er die Referenzen der Trainingskomponenten zerstört. Er stellt sicher, dass die Trainingsumgebung für eine erfolgreiche Wiederherstellung während des Prozesses 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:

Säuberungsvorgänge:

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 für das Training ohne Checkpoints mindestens 2 erforderlich sindnum_distributed_optimizer_instances, damit eine Optimizer-Replikation durchgeführt werden kann. 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:

Einrichtungsvorgänge:

setup_distributed()

Initialisieren Sie die Prozessgruppe entweder mit Präfix oder TCPStore mit einer Verbindung ohne Wurzel.

load_model_state_dict(checkpoint, strict=True)

Lädt das Status-Diktat des Modells mit Checkpointless-Recovery-Kompatibilität.

Parameter:

get_wrapper()

Holen Sie sich die HPCall Wrapper-Instanz für die Koordination der Fehlertoleranz.

Gibt zurück:

is_peft()

Prüfen Sie, ob PEFT (Parameter-Efficient Fine-Tuning) in der Trainingskonfiguration aktiviert ist, indem Sie nach PEFT-Callbacks suchen

Gibt zurück:

teardown()

Überschreiben Sie den systemeigenen PyTorch Lightning-Teardown, um die Bereinigung an Abbruchprozeduren 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-Trainings integriert.

Dieser Rückruf verwaltet die Schrittverfolgung, das Speichern von Checkpoints und die Koordination der Parameteraktualisierung für Funktionen zur Wiederherstellung während des Prozesses. Er dient als primärer Integrationspunkt zwischen PyTorch Lightning-Trainingsschleifen und Trainingsmechanismen HyperPod ohne Checkpoints und koordiniert die Fehlertoleranzoperationen während des gesamten Trainingszyklus.

Parameter

Attribute

Methoden

get_wrapper_from_trainer(trainer)

Holen Sie sich die Wrapper-Instanz vom Trainer für die Koordination der Fehlertoleranz. HPCall

Parameter:

Gibt zurück:

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

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

Parameter:

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

Geben Sie die Sperre für die Aktualisierung der Parameter am Ende jedes Trainingsstapels auf.

Parameter:

Hinweise:

get_peft_callback(trainer)

Ruft den PEFT-Callback aus der Rückrufliste des Trainers ab.

Parameter:

Gibt zurück:

_try_adapter_checkpointless_restore(trainer, params_to_save)

Versuchen Sie, die 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-Konnektor, der die Wiederherstellung ohne Checkpoint in das herkömmliche Laden von Checkpoints auf Festplatte integriert.

Dieser Konnektor erweitert den von PyTorch _CheckpointConnector Lightning und bietet so eine nahtlose Integration zwischen der Wiederherstellung ohne Checkpoint und der standardmäßigen Checkpoint-Wiederherstellung. Es versucht zunächst eine Wiederherstellung ohne Checkpoint und greift dann auf festplattenbasiertes Laden von Checkpoints zurück, falls eine Wiederherstellung ohne Checkpoint nicht möglich ist oder fehlschlägt.

Parameter

Erbt alle Parameter von _ CheckpointConnector

Methoden

resume_start(checkpoint_path=None)

Versuchen Sie, den Checkpoint vorab mit einer Wiederherstellungspriorität ohne Checkpoint 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()

Wird um NeMo eine AutoResume verzögerte Einrichtung erweitert, sodass eine Überprüfung der Wiederherstellung ohne Checkpoint vor der Auflösung des Checkpoint-Pfads möglich ist.

Diese Klasse implementiert eine zweiphasige Initialisierungsstrategie, die eine Überprüfung der Wiederherstellung ohne Checkpoint ermöglicht, bevor auf das herkömmliche Laden von Checkpoints auf der Festplatte zurückgegriffen wird. Sie verzögert die AutoResume Einrichtung bedingt, um eine vorzeitige Auflösung des Checkpoint-Pfads zu verhindern, sodass zunächst geprüft werden kann, ob eine Wiederherstellung ohne Checkpoint möglich ist CheckpointManager . peer-to-peer

Parameter

Erbt alle Parameter von AutoResume

Methoden

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

Verzögern Sie die AutoResume Einrichtung bedingt, um eine Überprüfung der Wiederherstellung ohne Checkpoint 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