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.
# HyperPod Checkpointless-Trainingsfunktionen
Auf den folgenden Seiten erfahren Sie mehr über die Trainingsfunktionen des Checkpointless-Trainings.
**Topics**
+ [Amazon SageMaker HyperPod Checkpointless-Schulungsrepositorien](#sagemaker-eks-checkpointless-repositories)
+ [Verbesserungen bei der Initialisierung der kollektiven Kommunikation](sagemaker-eks-checkpointless-features-communication.md)
+ [Dataloader mit Speicherzuweisung](sagemaker-eks-checkpointless-features-mmap.md)
+ [Prozessbegleitende Wiederherstellung und Training ohne Kontrollpunkte](sagemaker-eks-checkpointless-in-process-recovery.md)
## Amazon SageMaker HyperPod Checkpointless-Schulungsrepositorien
[ HyperPod Training ohne Checkpoint](https://github.com/aws/sagemaker-hyperpod-checkpointless-training#) beschleunigt die Wiederherstellung nach Clusterfehlern in großen, verteilten Trainingsumgebungen durch Optimierungen auf Framework-Ebene. Diese Optimierungen werden über ein Basis-Container-Image bereitgestellt, das erweiterte Verbesserungen der NCCL-Initialisierung, Optimierungen beim Laden von Daten sowie Komponenten für die Wiederherstellung während des Prozesses und ohne Checkpoint umfasst. Das HyperPod Checkpointless-Schulungspaket basiert auf dieser Grundlage.
Das Checkpointless-Training wird über drei Optimierungstracks ermöglicht, die zusammen laufen:
+ **Verbesserungen der Kommunikationsinitialisierung (NCCL und Gloo)** — Beseitigen Sie Kommunikationsengpässe, indem Sie Rang-Peer- und Ringinformationen dezentralisieren (rotes Feld unten).
+ **Optimierungen beim Laden von Daten** — Reduzieren Sie den Zeitaufwand für die Bereitstellung des ersten Datenstapels bei Neustartvorgängen (orangefarbene Felder unten).
+ **Reduzierung des Programmneustartaufwands** — Minimiert die Neustartkosten und ermöglicht die Wiederherstellung ohne Checkpoint durch Wiederherstellung von Prozessen auf fehlerfreien Knoten (blaue und grüne Felder unten).
![\[alt text not found\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimization-tracks.png)
# Verbesserungen bei der Initialisierung der kollektiven Kommunikation
NCCL und Gloo sind grundlegende Kommunikationsbibliotheken, die kollektive Operationen (wie All-Reduce und Broadcast) in verteilten Trainingsprozessen ermöglichen. Herkömmliche NCCL- und Gloo-Initialisierungen können jedoch zu Engpässen bei der Fehlerbehebung führen.
Beim standardmäßigen Wiederherstellungsprozess müssen alle Prozesse eine Verbindung zu einem zentralen Prozess herstellen TCPStore und über einen Stammprozess koordiniert werden, was zu einem teuren Overhead führt, der bei Neustarts besonders problematisch wird. Dieser zentralisierte Aufbau führt zu drei kritischen Problemen: Koordinationsaufwand aufgrund obligatorischer TCPStore Verbindungen, Verzögerungen bei der Wiederherstellung, da bei jedem Neustart die gesamte Initialisierungssequenz wiederholt werden muss, und eine einzelne Fehlerquelle im Stammprozess selbst. Dies führt bei jeder Initialisierung oder jedem Neustart der Schulung zu teuren, zentralen Koordinationsschritten.
HyperPod Das Training ohne Checkpoint beseitigt diese Koordinationsengpässe und ermöglicht eine schnellere Behebung von Fehlern, da die Initialisierung ohne Wurzeln und „“ erfolgt. TCPStoreless
## Konfigurationen ohne Wurzeln
Um Rootless zu aktivieren, kann man einfach die folgenden Umgebungsvariablen verfügbar machen.
```
export HPCT_USE_ROOTLESS=1 && \
sysctl -w net.ipv4.ip_local_port_range="20000 65535" && \
```
HPCT\$1USE\$1ROOTLESS: 0 oder 1. Wird verwendet, um Rootless ein- und auszuschalten
sysctl -w net.ipv4.ip\$1local\$1port\$1range="20000 65535": Legt den Portbereich des Systems fest
Sehen Sie sich [das Beispiel für die Aktivierung von Rootless an.](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml#L111-L113)
## Rootless
HyperPod Das Checkpointless-Training bietet neuartige Initialisierungsmethoden, Rootless und, für NCCL- und TCPStoreless Gloo-Prozessgruppen.
Die Implementierung dieser Optimierungen beinhaltet die Modifikation von NCCL, Gloo und: PyTorch
+ Erweiterung der Drittanbieterbibliothek APIs , um Rootless- und Storeless NCCL- und Gloo-Optimierungen zu ermöglichen und gleichzeitig die Abwärtskompatibilität aufrechtzuerhalten
+ Aktualisierung von Prozessgruppen-Backends, sodass optimierte Pfade unter bestimmten Bedingungen verwendet und Probleme bei der Wiederherstellung während des Prozesses behoben werden
+ Umgehung der teuren TCPStore Erstellung auf PyTorch verteilter Ebene bei gleichzeitiger Beibehaltung symmetrischer Adressmuster durch globale Gruppenzähler
Die folgende Grafik zeigt die Architektur der verteilten Trainingsbibliotheken und die Änderungen, die beim Training ohne Checkpoints vorgenommen wurden.
![\[Die folgende Grafik zeigt die Architektur der verteilten Trainingsbibliotheken und die Änderungen, die beim Training ohne Kontrollpunkte vorgenommen wurden.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-libraries.png)
### NCCL und Gloo
Dies sind unabhängige Pakete, die die Kernfunktionen der kollektiven Kommunikation erfüllen. Sie stellen Schlüssel APIs wie ncclCommInit Rank bereit, um Kommunikationsnetzwerke zu initialisieren, die zugrunde liegenden Ressourcen zu verwalten und kollektive Kommunikation durchzuführen. Nachdem benutzerdefinierte Änderungen in NCCL und Gloo vorgenommen wurden, optimieren Rootless und Storeless die Initialisierung des Kommunikationsnetzwerks (überspringen z. B. die Verbindung zum). TCPStore Sie können flexibel zwischen der Verwendung der ursprünglichen Codepfade und der optimierten Codepfade wechseln.
### PyTorch Prozessgruppen-Backend
Die Prozessgruppen-Backends, insbesondere ProcessGroup NCCL und ProcessGroupGloo, implementieren das, ProcessGroup APIs indem sie die entsprechenden zugrunde liegenden APIs Bibliotheken aufrufen. Da wir die Bibliotheken von Drittanbietern erweitern APIs, müssen wir sie ordnungsgemäß aufrufen und Codepfadwechsel auf der Grundlage der Kundenkonfigurationen vornehmen.
Zusätzlich zu den Optimierungscodepfaden ändern wir auch das Prozessgruppen-Backend, um die Wiederherstellung während des Prozesses zu unterstützen.
# Dataloader mit Speicherzuweisung
Ein weiterer Mehraufwand beim Neustart ist auf das Laden von Daten zurückzuführen: Der Trainingscluster bleibt inaktiv, während der Dataloader initialisiert, Daten von Remote-Dateisystemen herunterlädt und sie stapelweise verarbeitet.
Um dieses Problem zu lösen, führen wir den Memory Mapped DataLoader (MMAP) Dataloader ein, der vorab abgerufene Batches im persistenten Speicher zwischenspeichert und so sicherstellt, dass sie auch nach einem fehlerbedingten Neustart verfügbar bleiben. Dieser Ansatz macht die Einrichtung des Dataloaders überflüssig und ermöglicht es, das Training mithilfe zwischengespeicherter Batches sofort wieder aufzunehmen, während der Dataloader gleichzeitig die nachfolgenden Daten im Hintergrund neu initialisiert und abruft. Der Datencache befindet sich in jedem Rang, der Trainingsdaten benötigt, und verwaltet zwei Arten von Batches: kürzlich verbrauchte Batches, die für das Training verwendet wurden, und vorab abgerufene Batches, die sofort verwendet werden können.
![\[Dieses Bild zeigt den MMAP-Dataloader, die Caches und die verbrauchten Batches.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-mmap-dataloader.png)
Der MMAP-Dataloader bietet zwei folgende Funktionen:
+ **Datenvorabruf** — Ruft proaktiv vom Dataloader generierte Daten ab und speichert sie im Cache
+ **Persistentes Caching** — Speichert sowohl verbrauchte als auch vorab abgerufene Batches in einem temporären Dateisystem, das Prozessneustarts übersteht
Durch die Verwendung des Caches profitiert der Trainingsjob von folgenden Vorteilen:
+ **Reduzierter Speicherbedarf** — Nutzt die Speicherzuweisung, I/O um eine einzige gemeinsam genutzte Kopie der Daten im Host-CPU-Speicher zu verwalten, wodurch redundante Kopien zwischen GPU-Prozessen vermieden werden (z. B. Reduzierung von 8 Kopien auf 1 bei einer P5-Instance mit 8) GPUs
+ **Schnellere Wiederherstellung** — Reduziert die mittlere Zeit bis zum Neustart (MTTR), da das Training sofort nach zwischengespeicherten Batches wieder aufgenommen werden kann. Somit entfällt das Warten auf die Neuinitialisierung des Dataloaders und die Generierung des ersten Batches
## MMAP-Konfigurationen
Um MMAP zu verwenden, übergeben Sie einfach Ihr ursprüngliches Datenmodul an `MMAPDataModule`
```
data_module=MMAPDataModule(
data_module=MY_DATA_MODULE(...),
mmap_config=CacheResumeMMAPConfig(
cache_dir=self.cfg.mmap.cache_dir,
checkpoint_frequency=self.cfg.mmap.checkpoint_frequency),
)
```
`CacheResumeMMAPConfig`: Die MMAP-Dataloader-Parameter steuern den Speicherort des Cache-Verzeichnisses, die Größenbeschränkungen und die Delegierung des Datenabrufs. Standardmäßig ruft nur der TP-Rang 0 pro Knoten Daten aus der Quelle ab, während andere Ränge in derselben Datenreplikationsgruppe aus dem gemeinsam genutzten Cache lesen, wodurch redundante Übertragungen vermieden werden.
`MMAPDataModule`: Es umschließt das ursprüngliche Datenmodul und gibt den MMAP-Dataloader sowohl zum Trainieren als auch zur Validierung zurück.
Sehen Sie sich [das Beispiel für die Aktivierung von MMAP an](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune_checkpointless.py#L101-L109).
## API-Referenz
### CacheResumeMMAPConfig
```
class hyperpod_checkpointless_training.dataloader.config.CacheResumeMMAPConfig(
cache_dir='/dev/shm/pdl_cache',
prefetch_length=10,
val_prefetch_length=10,
lookback_length=2,
checkpoint_frequency=None,
model_parallel_group=None,
enable_batch_encryption=False)
```
Konfigurationsklasse für Cache-Resume-Memory-Mapped (MMAP) -Dataloader-Funktionalität beim Checkpointless-Training. HyperPod
Diese Konfiguration ermöglicht effizientes Laden von Daten mit Caching- und Prefetching-Funktionen, sodass das Training nach Ausfällen schnell wieder aufgenommen werden kann, indem zwischengespeicherte Datenstapel in Dateien mit Speicherzuweisung beibehalten werden.
**Parameter**
+ **cache\$1dir** (str, optional) — Verzeichnispfad zum Speichern zwischengespeicherter Datenstapel. Standard: „/\$1cache“ dev/shm/pdl
+ **prefetch\$1length** (int, optional) — Anzahl der Batches, die während des Trainings vorab abgerufen werden müssen. Standard: 10
+ **val\$1prefetch\$1length** (int, optional) — Anzahl der Batches, die während der Validierung vorab abgerufen werden sollen. Standard: 10
+ **lookback\$1length** (int, optional) — Anzahl der zuvor verwendeten Batches, die zur möglichen Wiederverwendung im Cache aufbewahrt werden sollen. Standard: 2
+ **checkpoint\$1frequency (int, optional) — Häufigkeit** der Modell-Checkpoint-Schritte. Wird zur Optimierung der Cache-Leistung verwendet. Standard: keiner
+ **model\$1parallel\$1group** (Objekt, optional) — Prozessgruppe für Modellparallelität. Bei None wird sie automatisch erstellt. Standard: keiner
+ **enable\$1batch\$1encryption (bool, optional) — Ob die Verschlüsselung** für zwischengespeicherte Batchdaten aktiviert werden soll. Standard: False
**Methoden**
```
create(dataloader_init_callable,
parallel_state_util,
step,
is_data_loading_rank,
create_model_parallel_group_callable,
name='Train',
is_val=False,
cached_len=0)
```
Erstellt eine konfigurierte MMAP-Dataloader-Instanz und gibt sie zurück.
**Parameter**
+ **dataloader\$1init\$1callable (Callable**) — Funktion zur Initialisierung des zugrunde liegenden Dataloaders
+ **parallel\$1state\$1util** (object) — Hilfsprogramm zur prozessübergreifenden Verwaltung des parallel Zustands
+ **step** (int) — Der Datenschritt, von dem aus während des Trainings fortgefahren werden soll
+ **is\$1data\$1loading\$1rank** (Callable) — Funktion, die True zurückgibt, wenn der aktuelle Rang Daten laden soll
+ **create\$1model\$1parallel\$1group\$1callable (Callable**) — Funktion zum Erstellen einer parallel Modellprozessgruppe
+ **name (str, optional) — Namenskennung** für den Dataloader. Standard: „Train“
+ **is\$1val** (bool, optional) — Ob es sich um einen Validierungs-Dataloader handelt. Standard: False
+ **cached\$1len** (int, optional) — Länge der zwischengespeicherten Daten bei Wiederaufnahme aus dem vorhandenen Cache. Standard: 0
Gibt `CacheResumePrefetchedDataLoader` oder — Konfigurierte MMAP-Dataloader-Instanz `CacheResumeReadDataLoader` zurück
`ValueError`Wird ausgelöst, wenn der Schrittparameter ist. `None`
**Beispiel**
```
from hyperpod_checkpointless_training.dataloader.config import CacheResumeMMAPConfig
# Create configuration
config = CacheResumeMMAPConfig(
cache_dir="/tmp/training_cache",
prefetch_length=20,
checkpoint_frequency=100,
enable_batch_encryption=False
)
# Create dataloader
dataloader = config.create(
dataloader_init_callable=my_dataloader_init,
parallel_state_util=parallel_util,
step=current_step,
is_data_loading_rank=lambda: rank == 0,
create_model_parallel_group_callable=create_mp_group,
name="TrainingData"
)
```
**Hinweise**
+ Das Cache-Verzeichnis sollte über ausreichend Speicherplatz und eine schnelle I/O Leistung verfügen (z. B. /dev/shm für In-Memory-Speicher).
+ Durch `checkpoint_frequency` die Einstellung wird die Cache-Leistung verbessert, indem die Cache-Verwaltung auf das Modell-Checkpointing abgestimmt wird
+ Für die Validierung von Dataloaders (`is_val=True`) wird der Schritt auf 0 zurückgesetzt und ein Kaltstart wird erzwungen
+ Je nachdem, ob der aktuelle Rang für das Laden von Daten verantwortlich ist, werden unterschiedliche Dataloader-Implementierungen verwendet
### MMAPDataModul
```
class hyperpod_checkpointless_training.dataloader.mmap_data_module.MMAPDataModule(
data_module,
mmap_config,
parallel_state_util=MegatronParallelStateUtil(),
is_data_loading_rank=None)
```
Ein PyTorch DataModule Lightning-Wrapper, der Funktionen zum Laden von Memory-Mapping-Daten (MMAP) auf vorhandene Daten anwendet, sodass das Training ohne Checkpoints möglich ist. DataModules
Dieser Kurs umschließt ein vorhandenes PyTorch Lightning DataModule und erweitert es um MMAP-Funktionen, wodurch effizientes Zwischenspeichern von Daten und eine schnelle Wiederherstellung bei Trainingsausfällen ermöglicht werden. Es behält die Kompatibilität mit der ursprünglichen DataModule Oberfläche bei und bietet gleichzeitig zusätzliche Trainingsfunktionen ohne Checkpoints.
Parameters
data\$1module (pl. LightningDataModule)
Der DataModule zu verpackende Basiswert (z. B. LLMData Modul)
mmap\$1config () MMAPConfig
Das MMAP-Konfigurationsobjekt, das Verhalten und Parameter beim Zwischenspeichern definiert
`parallel_state_util`(MegatronParallelStateUtil, optional)
Hilfsprogramm für die Verwaltung des parallel Zustands über verteilte Prozesse hinweg. Standard: MegatronParallelStateUtil ()
`is_data_loading_rank`(Aufrufbar, optional)
Funktion, die True zurückgibt, wenn der aktuelle Rang Daten laden soll. Bei None wird standardmäßig parallel\$1state\$1util.is\$1tp\$10 verwendet. Standard: keiner
**Attribute**
`global_step` (int)
Aktueller globaler Trainingsschritt, der für die Wiederaufnahme von Checkpoints verwendet wird
`cached_train_dl_len` (int)
Länge des Trainingsdataloaders im Cache
`cached_val_dl_len` (int)
Länge des Validierungs-Dataloaders im Cache
**Methoden**
```
setup(stage=None)
```
Richten Sie das zugrunde liegende Datenmodul für die angegebene Trainingsphase ein.
`stage`(str, optional)
Phase des Trainings („fit“, „validieren“, „testen“ oder „vorhersagen“). Standard: keiner
```
train_dataloader()
```
Erstellen Sie das Training DataLoader mit MMAP-Wrapping.
*Gibt zurück:* DataLoader — MMAP-umschlossenes Training DataLoader mit Caching- und Prefetching-Funktionen
```
val_dataloader()
```
Erstellen Sie die Validierung mit MMAP-Wrapping. DataLoader
*Gibt zurück:* DataLoader — MMAP-umschlossene Validierung mit Caching-Funktionen DataLoader
```
test_dataloader()
```
Erstellen Sie den Test, DataLoader wenn das zugrunde liegende Datenmodul ihn unterstützt.
*Gibt zurück:* DataLoader oder None — Test DataLoader aus dem zugrunde liegenden Datenmodul, oder None, falls nicht unterstützt
```
predict_dataloader()
```
Erstellen Sie die Prognose DataLoader , wenn das zugrunde liegende Datenmodul sie unterstützt.
*Gibt zurück:* DataLoader oder None — Prognose DataLoader aus dem zugrunde liegenden Datenmodul, oder None, falls nicht unterstützt
```
load_checkpoint(checkpoint)
```
Lädt Checkpoint-Informationen, um das Training ab einem bestimmten Schritt fortzusetzen.
Checkpoint (Diktat)
Checkpoint-Wörterbuch mit dem Schlüssel 'global\$1step'
```
get_underlying_data_module()
```
Ruft das zugrunde liegende verpackte Datenmodul ab.
*Gibt zurück:* pl. LightningDataModule — Das ursprüngliche Datenmodul, das verpackt wurde
```
state_dict()
```
Ruft das Statuswörterbuch der MMAP DataModule für Checkpoints ab.
*Gibt zurück:* dict — Wörterbuch, das zwischengespeicherte Dataloader-Längen enthält
```
load_state_dict(state_dict)
```
Lädt das Statuswörterbuch, um den MMAP-Status wiederherzustellen. DataModule
`state_dict`(Diktat)
Staatliches Wörterbuch, das geladen werden soll
**Eigenschaften**
```
data_sampler
```
Stellen Sie den Datensampler des zugrunde liegenden Datenmoduls dem NeMo Framework zur Verfügung.
*Gibt zurück:* object oder None — Der Datensampler aus dem zugrunde liegenden Datenmodul
**Beispiel**
```
from hyperpod_checkpointless_training.dataloader.mmap_data_module import MMAPDataModule
from hyperpod_checkpointless_training.dataloader.config import CacheResumeMMAPConfig
from my_project import MyLLMDataModule
# Create MMAP configuration
mmap_config = CacheResumeMMAPConfig(
cache_dir="/tmp/training_cache",
prefetch_length=20,
checkpoint_frequency=100
)
# Create original data module
original_data_module = MyLLMDataModule(
data_path="/path/to/data",
batch_size=32
)
# Wrap with MMAP capabilities
mmap_data_module = MMAPDataModule(
data_module=original_data_module,
mmap_config=mmap_config
)
# Use in PyTorch Lightning Trainer
trainer = pl.Trainer()
trainer.fit(model, data=mmap_data_module)
# Resume from checkpoint
checkpoint = {"global_step": 1000}
mmap_data_module.load_checkpoint(checkpoint)
```
**Hinweise**
+ Der Wrapper delegiert die meisten Attributzugriffe mit \$1\$1getattr\$1\$1 an das zugrunde liegende Datenmodul
+ Nur Ränge zum Laden von Daten initialisieren und verwenden das zugrunde liegende Datenmodul tatsächlich; andere Ränge verwenden gefälschte Dataloader
+ Die Längen der zwischengespeicherten Dataloader werden beibehalten, um die Leistung bei der Wiederaufnahme des Trainings zu optimieren
# 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:
+ **Prozessbegleitende Wiederherstellung:** Prozesse bleiben trotz Fehlern aktiv, wobei alle Modell- und Optimierungsstatus im GPU-Speicher mit den neuesten Werten beibehalten werden
+ **Reibungslose Behandlung von Abbrüchen:** kontrollierte Abbrüche und Bereinigung der Ressourcen bei betroffenen Vorgängen
+ **Neuausführung von Codeblöcken:** Nur die betroffenen Codesegmente innerhalb eines wiederausführbaren Codeblocks (RCB) werden erneut ausgeführt
+ **Wiederherstellung ohne Kontrollpunkt ohne verlorenen Trainingsfortschritt:** Da die Prozesse andauern und die Zustände im Speicher verbleiben, geht kein Trainingsfortschritt verloren. Wenn ein Fehler auftritt, wird das Training mit dem vorherigen Schritt fortgesetzt, im Gegensatz zum letzten gespeicherten Checkpoint
**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
```
+ `wait_rank`: Alle Ränge warten auf die Ranginformationen von der Infrastruktur. HyperpodTrainingOperator
+ `HPWrapper`: Python-Funktionswrapper, der Neustartfunktionen für einen wiederausführbaren Codeblock (RCB) ermöglicht. Die Implementierung verwendet einen Kontextmanager anstelle eines Python-Dekorators, da Dekoratoren die Anzahl der zur Laufzeit RCBs zu überwachenden Objekte nicht bestimmen können.
+ `CudaHealthCheck`: Stellt sicher, dass sich der CUDA-Kontext für den aktuellen Prozess in einem fehlerfreien Zustand befindet, indem es mit der GPU synchronisiert wird. Verwendet das in der Umgebungsvariablen LOCAL\$1RANK angegebene Gerät oder verwendet standardmäßig das CUDA-Gerät des Haupt-Threads, wenn LOCAL\$1RANK nicht gesetzt ist.
+ `HPAgentK8sAPIFactory`: Diese API ermöglicht ein Training ohne Checkpoint, um den Trainingsstatus anderer Pods im Kubernetes-Trainingscluster abzufragen. Sie bietet auch eine Barriere auf Infrastrukturebene, die sicherstellt, dass alle Ränge Abbruch- und Neustartvorgänge erfolgreich abschließen, bevor sie fortfahren.
+ `CheckpointManager`: Verwaltet die Checkpoints und die Wiederherstellung im Speicher und sorgt so für Fehlertoleranz ohne Checkpoints. peer-to-peer Es hat die folgenden Kernaufgaben:
+ **In-Memory-Checkpoint-Management**: Speichert und verwaltet NeMo Modell-Checkpoints im Arbeitsspeicher für eine schnelle Wiederherstellung ohne Festplatte I/O bei Wiederherstellungsszenarien ohne Checkpoint.
+ **Überprüfung der Durchführbarkeit der Wiederherstellung**: Ermittelt, ob eine Wiederherstellung ohne Checkpoint möglich ist, indem die globale Schrittkonsistenz, der Rangstatus und die Integrität des Modellstatus überprüft werden.
+ **Peer-to-Peer Orchestrierung der Wiederherstellung**: Koordiniert die Checkpoint-Übertragung zwischen fehlerfreien und ausgefallenen Rängen mithilfe verteilter Kommunikation für eine schnelle Wiederherstellung.
+ **RNG State Management**: Behält die Zustände des Zufallszahlengenerators in Python,, und Megatron bei und stellt sie wieder her NumPy PyTorch, um eine deterministische Wiederherstellung zu ermöglichen.
+ **[Optional] Checkpoint-Offload: Verlagerung im Speicher-Checkpoint** auf die CPU, wenn die GPU nicht über genügend Speicherkapazität verfügt.
+ `PEFTCheckpointManager`: Es wird erweitert, `CheckpointManager` indem die Gewichte des Basismodells für die PEFT-Feinabstimmung beibehalten werden.
+ `CheckpointlessAbortManager`: Verwaltet Abbruchvorgänge in einem Hintergrund-Thread, wenn ein Fehler auftritt. Standardmäßig werden Checkpointing TransformerEngine, TorchDistributed und abgebrochen. DataLoader Benutzer können bei Bedarf benutzerdefinierte Abbruch-Handler registrieren. Nach Abschluss des Abbruchs muss die gesamte Kommunikation beendet und alle Prozesse und Threads müssen beendet werden, um Ressourcenlecks zu verhindern.
+ `CheckpointlessFinalizeCleanup`: Führt die letzten Bereinigungsvorgänge im Haupt-Thread für Komponenten durch, die im Hintergrundthread nicht sicher abgebrochen oder bereinigt werden können.
+ `CheckpointlessMegatronStrategy`: Das erbt `MegatronStrategy` von der Form in Nemo. Beachten Sie, dass für das Training ohne Checkpoint mindestens 2 erforderlich sind`num_distributed_optimizer_instances`, damit die Optimizer-Replikation durchgeführt werden kann. Die Strategie kümmert sich auch um die Registrierung wichtiger Attribute und die Initialisierung von Prozessgruppen, z. B. ohne Wurzeln.
+ `CheckpointlessCallback`: Lightning-Rückruf, der das NeMo Training in das Fehlertoleranzsystem des Checkpointless-Trainings integriert. Es hat die folgenden Kernaufgaben:
+ **Lebenszyklusmanagement für Trainingsschritte**: Verfolgt den Trainingsfortschritt und koordiniert je ParameterUpdateLock nach Trainingsstatus (erster Schritt im Vergleich zu nachfolgenden Schritten) die Wiederherstellung enable/disable ohne Checkpoint.
+ **Koordination des Checkpoint-Zustands**: Verwaltet das Speichern/Wiederherstellen von Checkpoints im PEFT-Basismodell im Arbeitsspeicher.
+ `CheckpointlessCompatibleConnector`: Eine PTL`CheckpointConnector`, die versucht, die Checkpoint-Datei vorab in den Speicher zu laden, wobei der Quellpfad in dieser Priorität festgelegt wird:
+ versuchen Sie es mit einer Wiederherstellung ohne Checkpoint
+ Wenn checkpointless None zurückgibt, wird auf parent.resume\$1start () zurückgegriffen
Sehen Sie sich das Beispiel an, um Codes Trainingsfunktionen ohne [Checkpoint](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune.py) 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:
+ **Fehlererkennungsmodul:** Empfängt Benachrichtigungen über Infrastrukturfehler
+ **RCB-Definition APIs:** Ermöglicht es Benutzern, den wiederausführbaren Codeblock (RCB) in ihrem Code zu definieren
+ **Neustartmodul:** Beendet den RCB, bereinigt Ressourcen und startet den RCB neu
![\[Dieses Bild zeigt, wie ein Fehler-Controller-Modul während eines Trainings ohne Checkpoint Benachrichtigungen erhält, wenn ein Fehler auftritt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-fault-controller-module.png)
**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\$1distributed\$1optimizer\$1instances, 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 bei einem schwerwiegenden Ausfall (z. B. wenn mehrere Knoten gleichzeitig ausfallen), wird auf einen Neustart auf Jobebene zurückgegriffen.
| Art des Fehlers | Ursache | Art der Wiederherstellung | Wiederherstellungsmechanismus |
| --- | --- | --- | --- |
| Fehler während des Prozesses | Fehler auf Codeebene, Ausnahmen | Prozessbegleitende Wiederherstellung (IPR) | RCB innerhalb des bestehenden Prozesses erneut ausführen; intakte Prozesse bleiben aktiv |
| Fehler beim Neustart des Prozesses | Beschädigter CUDA-Kontext, Prozess beendet | Neustart auf Prozessebene (PLR) | SageMaker HyperPod Der geschulte Bediener startet die Prozesse neu; der Neustart des K8s-Pods wird übersprungen |
| Fehler beim Austausch des Knotens | Dauerhafter node/GPU Hardwarefehler | Neustart auf Jobebene (JLR) | Ersetzen Sie den ausgefallenen Knoten; starten Sie den gesamten Trainingsjob neu |
**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:
+ Übertragung **vorwärts/rückwärts:** Gehen Sie zurück zum Anfang des aktuellen Trainingsschritts und senden Sie den Modellstatus an die Ersatzknoten
+ **Optimierungsschritt:** Lassen Sie fehlerfreie Replikate den Schritt unter Sperrschutz abschließen, und senden Sie dann die aktualisierten Modellstatus an die Ersatzknoten
Diese Strategie stellt sicher, dass abgeschlossene Optimizer-Updates niemals verworfen werden, wodurch die Zeit für die Fehlerbehebung reduziert wird.
![\[Dieses Bild zeigt, wie mit einem Ausfall umgegangen wird, je nachdem, ob er vor oder nach dem Ausfall auftritt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimizer.png)
## Ablaufdiagramm des Checkpointless-Trainings
![\[Dieses Diagramm veranschaulicht den Trainingsablauf ohne Kontrollpunkte.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-flow.png)
Die folgenden Schritte beschreiben den Prozess der Fehlererkennung und Wiederherstellung ohne Checkpoint:
1. Die Trainingsschleife beginnt
1. Es tritt ein Fehler auf
1. Prüfen Sie die Durchführbarkeit eines Lebenslaufs ohne Checkpoint
1. Prüfen Sie, ob es möglich ist, einen Lebenslauf ohne Kontrollpunkt durchzuführen
+ Falls möglich, versuchen Sie eine Wiederaufnahme ohne Checkpoint
+ Wenn die Wiederaufnahme fehlschlägt, greifen Sie auf das Laden am Checkpoint aus dem Speicher zurück
+ Wenn die Wiederaufnahme erfolgreich ist, wird das Training im wiederhergestellten Zustand fortgesetzt
+ Falls dies nicht möglich ist, greifen Sie auf das Laden am Checkpoint aus dem Speicher zurück
1. Ressourcen bereinigen — Brechen Sie alle Prozessgruppen und Backends ab und geben Sie Ressourcen frei, um den Neustart vorzubereiten.
1. Trainingsschleife fortsetzen — eine neue Trainingsschleife beginnt und der Vorgang kehrt zu Schritt 1 zurück.
## API-Referenz
### wait\$1rank
```
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**
+ **Prozessüberprüfung**: Überspringt die Ausführung, wenn sie von einem Unterprozess aus aufgerufen wird (läuft nur in) MainProcess
+ **Umgebungsabruf**: Ruft aktuelle Variablen `RANK` und `WORLD_SIZE` aus Umgebungsvariablen ab
+ **HyperPod Kommunikation**: Ruft `hyperpod_wait_rank_info()` zum Abrufen von Ranginformationen von HyperPod
+ **Umgebungsupdate**: Aktualisiert die aktuelle Prozessumgebung mit arbeiterspezifischen Umgebungsvariablen, die von empfangen wurden HyperPod
**Umgebungsvariablen**
Die Funktion liest die folgenden Umgebungsvariablen:
+ **RANK** (*int*) — Aktueller Prozessrang (Standard: -1, falls nicht gesetzt)
+ **WORLD\$1SIZE** (*int*) — Gesamtzahl der Prozesse im verteilten Job (Standard: 0, falls nicht festgelegt)
**Erhöht**
+ **AssertionError**— Wenn die Antwort von nicht HyperPod das erwartete Format hat oder wenn Pflichtfelder fehlen
**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**
+ Wird nur im Hauptprozess ausgeführt; Aufrufe von Unterprozessen werden automatisch übersprungen
+ Die Funktion blockiert, bis die Ranginformationen HyperPod bereitgestellt werden
### 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**
+ **abort** (*Abort*, *optional*) — Die Ausführung wird asynchron abgebrochen, wenn Fehler erkannt werden. Standard: `Compose(HPAbortTorchDistributed())`
+ **finalize (Finalize**, *optional) — Lokaler *Finalisierungshandler** auf Rang, der beim Neustart ausgeführt wird. Standard: `None`
+ **health\$1check** (*HealthCheck*, *optional*) — Lokale Zustandsprüfung nach Rang, die während des Neustarts ausgeführt wird. Standard: `None`
+ **hp\$1api\$1factory** (*Callable*, *optional*) — Factory-Funktion zum Erstellen einer API für die Interaktion. HyperPod HyperPod Standard: `None`
+ **abort\$1timeout (*float*, *optional*) — Timeout** für den Abbruch eines Aufrufs im Fehlersteuerungsthread. Standard: `None`
+ **enabled** (*bool*, *optional*) — Aktiviert die Wrapper-Funktionalität. Wenn`False`, wird der Wrapper zu einem Pass-Through. Standard: `True`
+ **trace\$1file\$1path (*str*, *optional*) — Pfad zur** Trace-Datei für die Profilerstellung. VizTracer Standard: `None`
+ **async\$1raise\$1before\$1abort (*bool*, optional) — Aktiviert das Erhöhen vor dem Abbruch** *im Fehlerkontroll-Thread.* Standard: `True`
+ **early\$1abort\$1communicator (bool, optional) — Bricht den Kommunikator** **(NCCL/Gloo) ab, bevor der Dataloader abgebrochen wird.** Standard: `False`
+ **checkpoint\$1manager (Beliebig***,* *optional*) — Manager für die Behandlung von Checkpoints während der Wiederherstellung. Standard: `None`
+ **check\$1memory\$1status** (*bool*, *optional*) — Aktiviert die Überprüfung und Protokollierung des Speicherstatus. Standard: `True`
**Methoden**
```
def __call__(self, fn)
```
*Schließt eine Funktion ein, um Neustartfunktionen zu aktivieren.*
**Parameter:**
+ **fn** (*Callable*) — Die Funktion, die mit Neustartfunktionen umschlossen werden soll
**Gibt zurück:**
+ **Aufrufbar** — Umschlossene Funktion mit Neustartfunktionen oder ursprüngliche Funktion, falls deaktiviert
**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**
+ Der Wrapper muss verfügbar `torch.distributed` sein
+ Wenn`enabled=False`, wird der Wrapper zu einem Pass-Through und gibt die ursprüngliche Funktion unverändert zurück
+ Der Wrapper verwaltet globale Ressourcen wie die Überwachung von Threads während des gesamten Trainingszyklus
+ Unterstützt die VizTracer Profilerstellung, sofern sie bereitgestellt wird `trace_file_path`
+ Lässt sich HyperPod für eine koordinierte Fehlerbehandlung in verteilten Schulungen integrieren
### 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 gewährleistet eine konsistente Wiederherstellung aller Trainingsprozesse.
**Parameter**
+ **wrapper** (*HPWrapper*) — Der übergeordnete Wrapper, der globale Einstellungen für die prozessinterne Wiederherstellung enthält
**Attribute**
+ **step\$1upon\$1restart** (*int*) — Zähler, der die Schritte seit dem letzten Neustart verfolgt und zur Bestimmung der Neustartstrategie verwendet wird
**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:**
+ **call\$1ex** (*Exception*) — Ausnahme von der Überwachungsfunktion
```
def restart(term_ex)
```
Führt den Neustart-Handler aus, einschließlich Finalisierung, Garbage-Collection und Integritätsprüfungen.
**Parameter:**
+ **term\$1ex** (*RankShouldRestart*) — Eine Terminierungsausnahme, die den Neustart auslöst
```
def launch(fn, *a, **kw)
```
*Führt den RCB mit der richtigen Ausnahmebehandlung aus.*
**Parameter:**
+ **fn** (*Callable*) — Funktion, die ausgeführt werden soll
+ **a** — Funktionsargumente
+ **kw** — Argumente für Funktionsschlüsselwörter
```
def run(fn, a, kw)
```
Hauptausführungsschleife, die Neustarts und Barrierensynchronisierung verarbeitet.
**Parameter:**
+ **fn** (*Callable*) — Funktion, die ausgeführt werden soll
+ **a** — Funktionsargumente
+ **kw** — Argumente für Funktionsschlüsselwörter
```
def shutdown()
```
Threads zur Fehlerbehandlung und Überwachung herunterfahren.
**Hinweise**
+ Behandelt automatisch `RankShouldRestart` Ausnahmen für eine koordinierte Wiederherstellung
+ Verwaltet die Speicherverfolgung und Abbrüche sowie die Speicherbereinigung bei Neustarts
+ Unterstützt sowohl In-Process-Recovery- als auch PLR-Strategien (Process-Level Restart), die auf dem Timing von Fehlern basieren
### 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**
+ **timeout** (*datetime.timedelta, *optional*) — Timeout-Dauer* für GPU-Synchronisierungsvorgänge. Standard: `datetime.timedelta(seconds=30)`
**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:**
+ **state** (*HPState*) — Aktueller HyperPod Status, der Ranginformationen und verteilte Informationen enthält
+ **train\$1ex** (*Ausnahme*, *optional*) — Die ursprüngliche Trainingsausnahme, die den Neustart ausgelöst hat. Standard: `None`
**Gibt zurück:**
+ **Tupel** — Ein Tupel, das `(state, train_ex)` unverändert enthält, falls die Gesundheitsprüfung bestanden wurde
**Erhöht:**
+ **TimeoutError**— Wenn bei der GPU-Synchronisierung ein Timeout auftritt, was auf einen potenziell beschädigten CUDA-Kontext hindeutet
**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**
+ Verwendet Threading, um den Timeout-Schutz für die GPU-Synchronisierung zu implementieren
+ Entwickelt, um beschädigte CUDA-Kontexte zu erkennen, die eine erfolgreiche Wiederaufnahme des Trainings verhindern könnten
+ Sollte als Teil der Fehlertoleranz-Pipeline in verteilten Trainingsszenarien verwendet werden
### 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:**
+ **HPAgentk8SAPI — Konfigurierte API-Instanz** für die Kommunikation mit der Infrastruktur HyperPod
**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**
+ Entwickelt, um nahtlos mit HyperPod der Kubernetes-basierten Infrastruktur zusammenzuarbeiten. Es ist für die koordinierte Fehlerbehandlung und -behebung in verteilten Schulungsszenarien unerlässlich
### 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**
+ **enable\$1checksum** (*bool*, *optional*) — Aktiviert die Überprüfung der Modellstatus-Prüfsumme für Integritätsprüfungen während der Wiederherstellung. Standard: `False`
+ **enable\$1offload** (*bool*, *optional*) — Aktiviert das Checkpoint-Offloading vom GPU- in den CPU-Speicher, um die GPU-Speichernutzung zu reduzieren. Standard: `False`
**Attribute**
+ **global\$1step** (*int* oder *None*) — Aktueller Trainingsschritt, der dem gespeicherten Checkpoint zugeordnet ist
+ **rng\$1states** (*list* oder *None*) — Gespeicherte Zufallszahlengenerator-Zustände für die deterministische Wiederherstellung
+ **checksum\$1manager (*MemoryChecksumManager*) — Manager** für die Überprüfung der Prüfsumme des Modellstatus
+ **parameter\$1update\$1lock** (*ParameterUpdateLock*) — Sperre zur Koordination von Parameter-Updates während der Wiederherstellung
**Methoden**
```
save_checkpoint(trainer)
```
Speichert den NeMo Modell-Checkpoint im Speicher für eine mögliche Wiederherstellung ohne Checkpoint.
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
**Hinweise:**
+ Wird am Ende des Batches oder während der Ausnahmebehandlung CheckpointlessCallback aufgerufen
+ Erstellt Wiederherstellungspunkte ohne I/O Festplatten-Overhead
+ Speichert den vollständigen Modell-, Optimizer- und Scheduler-Status
```
delete_checkpoint()
```
Löschen Sie den In-Memory-Checkpoint und führen Sie Bereinigungsvorgänge durch.
**Hinweise:**
+ Löscht Checkpoint-Daten, RNG-Zustände und zwischengespeicherte Tensoren
+ Führt die Speicherbereinigung und die CUDA-Cache-Bereinigung durch
+ Wird nach erfolgreicher Wiederherstellung aufgerufen oder wenn der Checkpoint nicht mehr benötigt wird
```
try_checkpointless_load(trainer)
```
Versuchen Sie eine Wiederherstellung ohne Checkpoint, indem Sie den Status aus Peer-Rängen laden.
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
**Gibt zurück:**
+ **dict** oder **None** — Checkpoint wurde wiederhergestellt, falls erfolgreich, None, wenn ein Fallback auf die Festplatte erforderlich ist
**Hinweise:**
+ Wichtigster Einstiegspunkt für die Wiederherstellung ohne Checkpoint
+ Überprüft die Durchführbarkeit der Wiederherstellung, bevor eine P2P-Übertragung versucht wird
+ Bereinigt nach dem Wiederherstellungsversuch immer die In-Memory-Checkpoints
```
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:**
+ **trainer** (*pytorch\$1lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
+ **include\$1checksum\$1verification (bool, optional) — Ob die Prüfsummenvalidierung** **eingeschlossen werden soll.** Standard: `True`
**Gibt zurück:**
+ **bool** — True, wenn eine Wiederherstellung ohne Checkpoint möglich ist, andernfalls False
**Validierungskriterien:**
+ Gleichbleibende globale Schrittweite in gesunden Rängen
+ Es stehen ausreichend fehlerfreie Replikate für die Wiederherstellung zur Verfügung
+ Integrität der Prüfsumme für den Modellstatus (falls aktiviert)
```
store_rng_states()
```
Speichert alle Zustände des Zufallszahlengenerators für die deterministische Wiederherstellung.
**Hinweise:**
+ Erfasst Python- NumPy, PyTorch CPU/GPU- und Megatron-RNG-Zustände
+ Unverzichtbar für die Aufrechterhaltung des Trainingsdeterminismus nach der Erholung
```
load_rng_states()
```
Stellen Sie alle RNG-Zustände wieder her, um die deterministische Erholung fortzusetzen.
**Hinweise:**
+ Stellt alle zuvor gespeicherten RNG-Zustände wieder her
+ Stellt sicher, dass das Training mit identischen Zufallssequenzen fortgesetzt wird
```
maybe_offload_checkpoint()
```
Wenn Offload aktiviert ist, wird der Checkpoint von der GPU auf den CPU-Speicher verlagert.
**Hinweise:**
+ Reduziert die GPU-Speicherauslastung für große Modelle
+ Wird nur ausgeführt, wenn `enable_offload=True`
+ Behält den Zugriff auf Checkpoints für die Wiederherstellung bei
**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**
+ Nutzt verteilte Kommunikationsprimitive für eine effiziente P2P-Übertragung
+ Verarbeitet automatisch Tensor-DType-Konvertierungen und Geräteplatzierung
+ **MemoryChecksumManager**— Verwaltet die Integritätsprüfung des Modellzustands
### PEFTCheckpoint— Manager
```
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**
+ **enable\$1checksum** (*bool*, *optional*) — Aktiviert die Überprüfung der Prüfsumme des Modellstatus. Standard: `False`
+ **enable\$1offload (*bool*, optional) — Aktiviert das Checkpoint-Offloading** *in den CPU-Speicher.* Standard: `False`
**Zusätzliche Attribute**
+ **params\$1to\$1save** (*set) — Satz* von Parameternamen, die als Adapterparameter gespeichert werden sollen
+ **base\$1model\$1weights** (*dict* oder *None*) — Gewichte des Basismodells im Cache, einmal gespeichert und wiederverwendet
+ **base\$1model\$1keys\$1to\$1extract (list oder None) — Schlüssel zum Extrahieren** **von Basismodell-Tensoren während der P2P-Übertragung**
**Methoden**
```
maybe_save_base_model(trainer)
```
Speichert einmal die Gewichte des Basismodells und filtert dabei die Adapterparameter heraus.
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* PyTorch
**Hinweise:**
+ Speichert die Gewichte des Basismodells nur beim ersten Aufruf; nachfolgende Aufrufe sind keine Operationen
+ Filtert Adapterparameter heraus, um nur eingefrorene Basismodellgewichte zu speichern
+ Die Gewichte des Basismodells werden über mehrere Trainingseinheiten hinweg beibehalten
```
save_checkpoint(trainer)
```
Speichern Sie den Prüfpunkt des NeMo PEFT-Adaptermodells im Speicher für eine mögliche Wiederherstellung ohne Checkpoint.
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* PyTorch
**Hinweise:**
+ Ruft automatisch auf, wenn das Basismodell noch nicht gespeichert ist `maybe_save_base_model()`
+ Filtert den Checkpoint so, dass er nur Adapterparameter und Trainingsstatus enthält
+ Reduziert die Größe der Checkpoints im Vergleich zu Checkpoints des vollständigen Modells erheblich
```
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:**
+ **trainer** (*pytorch\$1lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
**Gibt zurück:**
+ **dict** oder **None** — Der Basismodell-Checkpoint wurde wiederhergestellt, falls erfolgreich, None, wenn ein Fallback erforderlich ist
**Hinweise:**
+ Wird während der Modellinitialisierung verwendet, um die Gewichte des Basismodells wiederherzustellen
+ Löscht die Gewichte des Basismodells nach der Wiederherstellung nicht (wird für die Wiederverwendung aufbewahrt)
+ Optimiert für model-weights-only Wiederherstellungsszenarien
```
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:**
+ **trainer** (*pytorch\$1lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
**Gibt zurück:**
+ **dict** oder **None** — Der Adapter-Checkpoint wurde wiederhergestellt, falls erfolgreich, None, wenn ein Fallback erforderlich ist
**Hinweise:**
+ Stellt nur Adapterparameter, Optimizer-Status und Scheduler wieder her
+ Lädt nach erfolgreicher Wiederherstellung automatisch den Optimizer- und Scheduler-Status
+ Bereinigt die Adapter-Checkpoints nach dem Wiederherstellungsversuch
```
is_adapter_key(key)
```
Prüfen Sie, ob der State-Dict-Schlüssel zu den Adapterparametern gehört.
**Parameter:**
+ **key** (*str* oder *tuple) — Zu* prüfender State-Dict-Schlüssel
**Gibt zurück:**
+ **bool** — True, wenn der Schlüssel ein Adapterparameter ist, False, wenn der Basismodellparameter
**Erkennungslogik:**
+ Prüft, ob der Schlüssel `params_to_save` gesetzt ist
+ Identifiziert Schlüssel, die „.adapter“ enthalten. substring
+ Identifiziert Schlüssel, die mit „.adapters“ enden
+ Überprüft bei Tupelschlüsseln, ob der Parameter Farbverläufe erfordert
```
maybe_offload_checkpoint()
```
Verlagert die Gewichte des Basismodells von der GPU auf den CPU-Speicher.
**Hinweise:**
+ Erweitert die übergeordnete Methode, um die Gewichtsverlagerung des Basismodells zu handhaben
+ Die Gewichte der Adapter sind in der Regel gering und müssen nicht abgeladen werden
+ Setzt ein internes Kennzeichen, um den Offload-Status zu verfolgen
**Hinweise**
+ Speziell für parametereffiziente Feinabstimmungsszenarien (LoRa, Adapter usw.) konzipiert
+ Sorgt automatisch für die Trennung von Basismodell- und Adapterparametern
**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:**
+ **Compose** — Standardmäßig erstellte Abbruchinstanz mit allen Abbruchkomponenten
**Standardkomponenten:**
+ **AbortTransformerEngine()** — Bereinigt Ressourcen TransformerEngine
+ **HPCheckpointingAbort ()** — Führt die Bereinigung des Checkpoint-Systems durch
+ **HPAbortTorchDistributed()** — Bricht verteilte Operationen ab PyTorch
+ **HPDataLoaderAbort()** — Stoppt und bereinigt Datenlader
```
create_custom_abort(abort_instances)
```
*Erstellen Sie eine benutzerdefinierte Abbruchmeldung, die nur die angegebenen Abbruchinstanzen enthält.*
**Parameter:**
+ **abort\$1instances** (*Abort) — Variable Anzahl von Abbruchinstanzen*, die in die Erstellung aufgenommen werden sollen
**Gibt zurück:**
+ **Compose** — Neue komponierte Abbruchinstanz, die nur die angegebenen Komponenten enthält
**Löst aus:**
+ **ValueError**— Wenn keine Abbruchinstanzen bereitgestellt werden
```
override_abort(abort_compose, abort_type, new_abort)
```
Ersetzt eine bestimmte Abbruchkomponente in einer Compose-Instanz durch eine neue Komponente.
**Parameter:**
+ **abort\$1compose (*Compose***) — Die ursprüngliche Compose-Instanz, die geändert werden soll
+ **abort\$1type (type**) — Der *Typ* der Abbruchkomponente, die ersetzt werden soll (z. B.) `HPCheckpointingAbort`
+ **new\$1abort (Abort***) — Die neue Abbruchinstanz*, die als Ersatz verwendet werden soll
**Gibt zurück:**
+ **Compose** — Neue Compose-Instanz, bei der die angegebene Komponente ersetzt wurde
**Erhöht:**
+ **ValueError**— Wenn abort\$1compose kein Attribut 'instances' hat
**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**
+ Benutzerdefinierte Konfigurationen ermöglichen eine fein abgestimmte Steuerung des Bereinigungsverhaltens
+ Abbruchvorgänge sind entscheidend für die ordnungsgemäße Bereinigung der Ressourcen bei der Fehlerbehebung
### 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**
+ **trainer** (*pytorch\$1lightning.Trainer oder *None*) — Verweis auf die Lightning-Trainer-Instanz* PyTorch
**Methoden**
```
__call__(*a, **kw)
```
**Führen Sie umfassende Bereinigungsvorgänge aus, um die Wiederherstellung während des Prozesses vorzubereiten.**
*Parameter:*
+ **a** — Variable Positionsargumente (von der Finalize-Schnittstelle übernommen)
+ **kw** — Variable Schlüsselwortargumente (von der Finalize-Schnittstelle übernommen)
**Säuberungsvorgänge:**
+ **Megatron Framework Cleanup — Aufrufe zur Bereinigung** von Megatron-spezifischen `abort_megatron()` Ressourcen
+ TransformerEngine Cleanup — Aufrufe zur **Bereinigung** von Ressourcen `abort_te()` TransformerEngine
+ **RoPE Cleanup** — Aufrufe `cleanup_rope()` zum Aufräumen von Ressourcen in rotierenden Positionen
+ **DDP Cleanup** — Aufrufe `cleanup_ddp()` zur Bereinigung von Ressourcen DistributedDataParallel
+ **Module Reloading** — Aufrufe `reload_megatron_and_te()` zum Neuladen von Framework-Modulen
+ **Lightning-Modulbereinigung** — Löscht optional das Lightning-Modul, um den GPU-Speicher zu reduzieren
+ **Speicherbereinigung** — Zerstört die Verweise der Trainingskomponenten auf freien Arbeitsspeicher
```
register_attributes(trainer)
```
*Registrieren Sie die Trainer-Instanz für die Verwendung bei Bereinigungsvorgängen.*
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* zur Registrierung PyTorch
**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**
+ Bereinigungsvorgänge werden in einer bestimmten Reihenfolge ausgeführt, um Abhängigkeitsprobleme zu vermeiden
+ Die Speicherbereinigung verwendet Garbage-Collection-Introspektion, um Zielobjekte zu finden
+ Alle Bereinigungsvorgänge sind so konzipiert, dass sie idempotent sind und sicher wiederholt werden können
### 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 sind`num_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**
+ NeMo MegatronStrategy Standard-Initialisierungsparameter
+ Konfigurationsoptionen für verteilte Schulungen
+ Einstellungen für Modellparallelität
**Attribute**
+ **base\$1store** *(torch.distributed). TCPStore*oder *None*) — Verteilter Speicher für die Koordination von Prozessgruppen
**Methoden**
```
setup(trainer)
```
Initialisieren Sie die Strategie und registrieren Sie die Fehlertoleranzkomponenten beim Trainer.
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* PyTorch
**Einrichtungsvorgänge:**
+ **Übergeordnetes Setup** — Ruft das übergeordnete MegatronStrategy Setup auf
+ **Registrierung von Fehlerinjektionen** — Registriert HPFault InjectionCallback Hooks, falls vorhanden
+ **Registrierung abschließen — Registriert** den Trainer bei den Finalize Cleanup-Handlern
+ **Registrierung abbrechen — Registriert den Trainer bei Abort-Handlern**, die dies unterstützen
```
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:**
+ **checkpoint** (*Mapping [str, Any]) — Checkpoint-Wörterbuch,* das den Modellstatus enthält
+ **strict** (*bool*, *optional*) — Ob der Abgleich von State-Dict-Schlüsseln strikt erzwungen werden soll. Standard: `True`
```
get_wrapper()
```
Holen Sie sich die HPCall Wrapper-Instanz für die Koordination der Fehlertoleranz.
**Gibt zurück:**
+ **HPCallWrapper** — Die Wrapper-Instanz, die aus Gründen der Fehlertoleranz an den Trainer angeschlossen ist
```
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:**
+ **bool** — Wahr, wenn ein PEFT-Callback vorhanden ist, andernfalls False
```
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**
+ **enable\$1inprocess** *(*bool*, optional) — Aktiviert Funktionen zur prozessinternen Wiederherstellung.* Standard: `False`
+ **enable\$1checkpointless** *(*bool*, optional) — Aktiviert die Wiederherstellung ohne Prüfpunkt (erforderlich).* `enable_inprocess=True` Standard: `False`
+ **enable\$1checksum (bool, optional) — Aktiviert die Überprüfung der Modellstatus-Prüfsumme** *(erforderlich**).* `enable_checkpointless=True` Standard: `False`
+ **clean\$1tensor\$1hook** (*bool*, *optional*) — Löscht während der Bereinigung Tensor-Hooks von allen GPU-Tensoren (teurer Vorgang). Standard: `False`
+ **clean\$1lightning\$1module (*bool*, optional) — Aktiviert die Bereinigung des Lightning-Moduls***, um nach jedem Neustart GPU-Speicher freizugeben.* Standard: `False`
**Attribute**
+ ***tried\$1adapter\$1checkpointless (bool) — Markierung, um nachzuverfolgen, ob versucht wurde, den Adapter ohne Checkpoint wiederherzustellen***
**Methoden**
```
get_wrapper_from_trainer(trainer)
```
Holen Sie sich die Wrapper-Instanz vom Trainer für die Koordination der Fehlertoleranz. HPCall
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* PyTorch
**Gibt zurück:**
+ **HPCallWrapper** — Die Wrapper-Instanz für Fehlertoleranzoperationen
```
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:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* PyTorch
+ **pl\$1module** (*pytorch\$1lightning). LightningModule*) — Lightning-Modul wird trainiert
+ **batch** — Aktuelle Trainingsstapeldaten
+ **batch\$1idx** (*int*) — Index des aktuellen Batches
+ args — **Zusätzliche Positionsargumente**
+ **kwargs** — Zusätzliche Schlüsselwortargumente
```
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:**
+ **trainer** (*pytorch\$1lightning.Trainer) — Lightning-Trainer-Instanz* PyTorch
+ **pl\$1module** (*pytorch\$1lightning). LightningModule*) — Lightning-Modul wird trainiert
+ **outputs** (*STEP\$1OUTPUT*) — Ausgaben von Trainingsschritten
+ **batch** (*Any*) — Aktuelle Trainingsstapeldaten
+ **batch\$1idx** (*int*) — Index des aktuellen Batches
**Hinweise:**
+ Der Zeitpunkt der Freigabe von Sperren stellt sicher, dass die Wiederherstellung ohne Checkpoint fortgesetzt werden kann, nachdem die Parameteraktualisierungen abgeschlossen sind
+ Wird nur ausgeführt, wenn sowohl als auch wahr sind `enable_inprocess` `enable_checkpointless`
```
get_peft_callback(trainer)
```
*Ruft den PEFT-Callback aus der Rückrufliste des Trainers ab.*
**Parameter:**
+ **trainer** (*pyTorch\$1Lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
**Gibt zurück:**
+ **PEFT** oder **None** — PEFT-Callback-Instanz, falls gefunden, sonst None
```
_try_adapter_checkpointless_restore(trainer, params_to_save)
```
*Versuchen Sie, die PEFT-Adapterparameter ohne Checkpoint wiederherzustellen.*
**Parameter:**
+ **trainer** (*pytorch\$1lightning.Trainer*) — Lightning-Trainer-Instanz PyTorch
+ **params\$1to\$1save** (*set) — Satz* von Parameternamen, die als Adapterparameter gespeichert werden sollen
**Hinweise:**
+ Wird nur einmal pro Trainingseinheit ausgeführt (wird durch das Flag gesteuert) `tried_adapter_checkpointless`
+ Konfiguriert den Checkpoint Manager mit Adapterparameterinformationen
**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**
+ **clean\$1tensor\$1hook: Entfernt Tensor-Hooks** während der Bereinigung (teuer, aber gründlich)
+ **clean\$1lightning\$1module**: Gibt den GPU-Speicher des Lightning-Moduls bei Neustarts frei
+ Beide Optionen tragen dazu bei, den Speicherbedarf bei der Fehlerbehebung zu reduzieren
+ Koordiniert mit ParameterUpdateLock für die Thread-sichere Nachverfolgung von Parameteraktualisierungen
### 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 \$1 CheckpointConnector
**Methoden**
```
resume_start(checkpoint_path=None)
```
Versuchen Sie, den Checkpoint vorab mit einer Wiederherstellungspriorität ohne Checkpoint zu laden.
**Parameter:**
+ **checkpoint\$1path** (*str* oder *None*, *optional*) — Pfad zum Festplatten-Checkpoint für Fallback. Standard: `None`
```
resume_end()
```
Schließen Sie den Checkpoint-Ladevorgang ab und führen Sie Operationen nach dem Laden durch.
**Hinweise**
+ Erweitert die interne `_CheckpointConnector` Klasse von PyTorch Lightning um Unterstützung für die Wiederherstellung ohne Checkpoint
+ Behält die volle Kompatibilität mit standardmäßigen PyTorch Lightning-Checkpoint-Workflows bei
### 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:**
+ **trainer** *(*pytorch\$1lightning.trainer oder lightning.Fabric.Fabric) — Lightning-Trainer* oder Fabric-Instanz* PyTorch
+ **model** *(optional) —* Modellinstanz für die Einrichtung. Standard: `None`
+ **force\$1setup** (*bool*, *optional*) — Bei True wird die Verzögerung umgangen und das Setup sofort ausgeführt AutoResume . Standard: `False`
**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**
+ Erweitert NeMo die AutoResume Klasse um einen Verzögerungsmechanismus, der eine Wiederherstellung ohne Checkpoint ermöglicht
+ Funktioniert in Verbindung mit `CheckpointlessCompatibleConnector` für einen vollständigen Wiederherstellungs-Workflow