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.
# Dataloader mit Speicherabbildung
Ein weiterer Neustart-Overhead entsteht durch das Laden von Daten: Der Trainingscluster bleibt inaktiv, während der Datenlader initialisiert wird, 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. Durch diesen Ansatz entfällt die Einrichtungszeit des Dataloaders und das Training kann mithilfe zwischengespeicherter Batches sofort wieder aufgenommen werden, während der Dataloader gleichzeitig nachfolgende Daten im Hintergrund neu initialisiert und abruft. Der Datencache befindet sich auf jedem Rank, der Trainingsdaten benötigt, und verwaltet zwei Arten von Batches: kürzlich verbrauchte Batches, die für das Training verwendet wurden, und Batches, die vorab abgerufen wurden, und Batches, die sofort verwendet werden können.
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 Memory-Mapping, I/O um eine einzige gemeinsam genutzte Kopie der Daten im Speicher der Host-CPU zu verwalten, wodurch redundante Kopien zwischen GPU-Prozessen vermieden werden (z. B. reduziert sich die Anzahl von 8 Kopien auf eine auf einer p5-Instance mit 8 GPUs)
+ **Schnellere Wiederherstellung ** — Reduziert die mittlere Zeit bis zum Neustart (MTTR), da das Training sofort aus zwischengespeicherten Batches fortgesetzt werden kann, sodass das Warten auf die Neuinitialisierung des Datenloaders und die Generierung des ersten Batches entfällt
## MMAP-Konfigurationen
Um MMAP zu verwenden, geben Sie einfach Ihr ursprüngliches Datenmodul ein `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 für den Zug als auch für die Validierung zurück.
Sehen Sie sich [ das Beispiel für die Aktivierung von MMAP ](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune_checkpointless.py#L101-L109) an.
## 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 die Cache-Resume Memory-Mapped (MMAP) -Dataloader-Funktionalität beim Training ohne Checkpoint. HyperPod
Diese Konfiguration ermöglicht ein effizientes Laden von Daten mit Caching- und Prefetching-Funktionen, sodass das Training nach Fehlern schnell wieder aufgenommen werden kann, indem zwischengespeicherte Datenstapel in Dateien gespeichert werden, die dem Speicher zugeordnet sind.
**Parameter**
+ **cache\_dir ** (str, optional) — Verzeichnispfad zum Speichern zwischengespeicherter Datenstapel. Standard: „//pdl\_cache“ dev/shm
+ **prefetch\_length ** (int, optional) — Anzahl der Batches, die während des Trainings vorab abgerufen werden sollen. Standard: 10
+ **val\_prefetch\_length ** (int, optional) — Anzahl der Batches, die während der Validierung vorab abgerufen werden sollen. Standard: 10
+ **lookback\_length ** (int, optional) — Anzahl der zuvor verwendeten Batches, die zur möglichen Wiederverwendung im Cache aufbewahrt werden sollen. Standard: 2
+ **checkpoint\_frequency ** (int, optional) — Häufigkeit der Checkpointing-Schritte des Modells. Wird für die Optimierung der Cache-Leistung verwendet. Standard: keiner
+ **model\_parallel\_group ** (Objekt, optional) — Prozessgruppe für Modellparallelität. Wenn None, wird sie automatisch erstellt. Standard: keiner
+ **enable\_batch\_encryption ** (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\_init\_callable (**Callable) — Funktion zur Initialisierung des zugrunde liegenden Dataloaders
+ **parallel\_state\_util (object) — Hilfsprogramm zur Verwaltung des parallelen Zustands zwischen Prozessen **
+ **step ** (int) — Der Datenschritt, mit dem während des Trainings fortgefahren werden soll
+ **is\_data\_loading\_rank ** (Callable) — Funktion, die True zurückgibt, wenn der aktuelle Rang Daten laden soll
+ **create\_model\_parallel\_group\_callable (Callable) — Funktion zum Erstellen einer modellparallelen Prozessgruppe **
+ **name ** (str, optional) — Namenskennung für den Datenlader. Standard: „Zug“
+ **is\_val ** (bool, optional) — Ob dies ein Validierungs-Dataloader ist. Standard: False
+ **cached\_len ** (int, optional) — Länge der zwischengespeicherten Daten bei der Wiederaufnahme aus dem vorhandenen Cache. Standard: 0
Gibt `CacheResumePrefetchedDataLoader` oder — Konfigurierte MMAP-Dataloader-Instanz `CacheResumeReadDataLoader` zurück
`ValueError`Wird ausgelöst, wenn der Schrittparameter `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 speicherinternen Speicher).
+ Die Einstellung `checkpoint_frequency` verbessert die Cache-Leistung, indem die Cache-Verwaltung an das Modell-Checkpointing angepasst wird
+ Bei Validierungsdataloadern (`is_val=True`) wird der Schritt auf 0 zurückgesetzt und ein Kaltstart erzwungen
+ Je nachdem, ob der aktuelle Rang für das Laden der Daten verantwortlich ist, werden unterschiedliche Dataloader-Implementierungen verwendet
### MMAPDataModule
```
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 Speicher-Mapping-Funktionen (MMAP) zum Laden vorhandener Daten für das Training ohne Checkpoints anwendet. DataModules
In diesem Kurs wird ein vorhandenes PyTorch Lightning verpackt DataModule und um MMAP-Funktionen erweitert, wodurch ein effizientes Zwischenspeichern von Daten und eine schnelle Wiederherstellung bei Trainingsausfällen ermöglicht wird. Sie gewährleistet die Kompatibilität mit der ursprünglichen DataModule Oberfläche und bietet gleichzeitig Trainingsfunktionen ohne Checkpoints.
Parameters
Datenmodul (pl. LightningDataModule)
Der DataModule zu wickelnde Basiswert (z. B. LLMDataModule)
mmap\_config (mmapConfig)
Das MMAP-Konfigurationsobjekt, das das Caching-Verhalten und die Parameter definiert
`parallel_state_util`(MegatronParallelStateUtil, optional)
Hilfsprogramm zur Verwaltung von Parallelzuständen ü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\_state\_util.is\_tp\_0 verwendet. Standard: keiner
**Attribute**
`global_step` (int)
Aktueller globaler Trainingsschritt, der für die Wiederaufnahme an Checkpoints verwendet wird
`cached_train_dl_len` (int)
Länge des Trainingsdataloaders im Cache
`cached_val_dl_len` (int)
Zwischengespeicherte Länge des Validierungs-Dataloaders
**Methoden**
```
setup(stage=None)
```
Richten Sie das zugrunde liegende Datenmodul für die angegebene Trainingsphase ein.
`stage`(str, optional)
Phase des Trainings („anpassen“, „validieren“, „testen“ oder „vorhersagen“). Standard: keiner
```
train_dataloader()
```
Erstellen Sie das Training DataLoader mit MMAP-Wrapping.
*Gibt Folgendes zurück: * DataLoader — MMAP-wrapped Training DataLoader mit Caching- und Prefetching-Funktionen
```
val_dataloader()
```
Erstellen Sie die Validierung DataLoader mit MMAP-Wrapping.
*Gibt Folgendes zurück: * DataLoader — MMAP-wrapped Validierung DataLoader mit Caching-Funktionen
```
test_dataloader()
```
Erstellen Sie den Test DataLoader , wenn das zugrunde liegende Datenmodul ihn unterstützt.
*Gibt Folgendes zurück: * DataLoader oder None — Test DataLoader aus dem zugrunde liegenden Datenmodul, oder None, wenn dies nicht unterstützt wird
```
predict_dataloader()
```
Erstellen Sie die Prognose DataLoader , wenn das zugrunde liegende Datenmodul sie unterstützt.
*Gibt Folgendes zurück: * DataLoader oder None — Predict DataLoader aus dem zugrunde liegenden Datenmodul, oder None, wenn es nicht unterstützt wird
```
load_checkpoint(checkpoint)
```
Laden Sie Checkpoint-Informationen, um das Training ab einem bestimmten Schritt fortzusetzen.
Checkpoint (Diktat)
Checkpoint-Wörterbuch, das den Schlüssel 'global\_step' enthält
```
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 State-Wörterbuch des MMAP DataModule für Checkpoints ab.
*Gibt Folgendes zurück: * dict — Wörterbuch, das zwischengespeicherte Dataloader-Längen enthält
```
load_state_dict(state_dict)
```
Laden Sie das Statuswörterbuch, um den MMAP-Status wiederherzustellen. DataModule
`state_dict`(Diktat)
Zustandswörterbuch zum Laden
**Eigenschaften**
```
data_sampler
```
Stellen Sie den Datensampler des zugrunde liegenden Datenmoduls dem NeMo Framework zur Verfügung.
*Rückgabe: * object or 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 mithilfe von \_\_getattr\_\_ an das zugrunde liegende Datenmodul
+ Nur Ränge, die Daten laden, initialisieren und verwenden das zugrundeliegende Datenmodul; andere Ränge verwenden gefälschte Datenlader
+ Die Länge der zwischengespeicherten Datenlader wird beibehalten, um die Leistung bei Wiederaufnahme des Trainings zu optimieren