Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Chargeur de données mappé en mémoire

Le chargement des données représente une autre surcharge liée au redémarrage : le cluster d'apprentissage reste inactif pendant que le chargeur de données s'initialise, télécharge les données depuis des systèmes de fichiers distants et les traite par lots.

Pour y remédier, nous introduisons le chargeur de données MMAP DataLoader (Memory Mapped), qui met en cache les lots préchargés dans la mémoire persistante, garantissant ainsi leur disponibilité même après un redémarrage provoqué par une erreur. Cette approche élimine le temps de configuration du chargeur de données et permet de reprendre immédiatement l'entraînement à l'aide de lots mis en cache, tandis que le chargeur de données se réinitialise et récupère simultanément les données suivantes en arrière-plan. Le cache de données se trouve sur chaque rang qui nécessite des données d'entraînement et gère deux types de lots : les lots récemment consommés qui ont été utilisés pour l'entraînement et les lots préchargés prêts à être utilisés immédiatement.

Le chargeur de données MMAP offre deux fonctionnalités suivantes :

En utilisant le cache, la tâche de formation bénéficiera des avantages suivants :

Configurations MMAP

Pour utiliser MMAP, il vous suffit de transmettre votre module de données d'origine dans 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: les paramètres du chargeur de données MMAP contrôlent l'emplacement du répertoire de cache, les limites de taille et la délégation de récupération des données. Par défaut, seul le rang TP 0 par nœud extrait les données depuis la source, tandis que les autres rangs du même groupe de réplication de données lisent à partir du cache partagé, ce qui élimine les transferts redondants.

MMAPDataModule: Il enveloppe le module de données d'origine et renvoie le chargeur de données mmap pour le train et la validation.

Consultez l'exemple d'activation de MMAP.

Référence des API

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)

Classe de configuration pour la fonctionnalité de chargeur de données MMAP (cache-resume memory-mapped) dans le cadre d'un entraînement sans point de contrôle. HyperPod

Cette configuration permet un chargement efficace des données grâce à des fonctionnalités de mise en cache et de prélecture, ce qui permet de reprendre rapidement la formation en cas de panne en conservant les lots de données mis en cache dans des fichiers mappés en mémoire.

Paramètres

Méthodes

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)

Crée et renvoie une instance de chargeur de données MMAP configurée.

Paramètres

Renvoie CacheResumePrefetchedDataLoader ou CacheResumeReadDataLoader : instance de chargeur de données MMAP configurée

Augmente ValueError si le paramètre step estNone.

Exemple

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

Remarques

MMAPDataModule

class hyperpod_checkpointless_training.dataloader.mmap_data_module.MMAPDataModule(  
    data_module,  
    mmap_config,  
    parallel_state_util=MegatronParallelStateUtil(),  
    is_data_loading_rank=None)

Un DataModule wrapper PyTorch Lightning qui applique des fonctionnalités de chargement de données mappées en mémoire (MMAP) à un entraînement existant pour un entraînement sans point de contrôle. DataModules

Cette classe complète un PyTorch Lightning existant DataModule et l'améliore avec la fonctionnalité MMAP, permettant une mise en cache efficace des données et une restauration rapide en cas d'échec d'entraînement. Il maintient la compatibilité avec l' DataModule interface d'origine tout en ajoutant des fonctionnalités d'entraînement sans point de contrôle.

Parameters

Attributs

Méthodes

setup(stage=None)

Configurez le module de données sous-jacent pour l'étape de formation spécifiée.

train_dataloader()

Créez la formation à l' DataLoader aide de l'encapsulation MMAP.

Renvoie : DataLoader — MMAP-wrapped entraînement DataLoader avec fonctionnalités de mise en cache et de prélecture

val_dataloader()

Créez la validation à l' DataLoader aide de l'encapsulation MMAP.

Renvoie : DataLoader — MMAP-wrapped validation DataLoader avec fonctionnalités de mise en cache

test_dataloader()

Créez le test DataLoader si le module de données sous-jacent le prend en charge.

Renvoie : DataLoader ou Aucun — Test DataLoader à partir du module de données sous-jacent, ou Aucun s'il n'est pas pris en charge

predict_dataloader()

Créez la prédiction DataLoader si le module de données sous-jacent la prend en charge.

Renvoie : DataLoader ou Aucun — Prédiction DataLoader à partir du module de données sous-jacent, ou Aucun s'il n'est pas pris en charge

load_checkpoint(checkpoint)

Chargez les informations relatives aux points de contrôle pour reprendre l'entraînement à partir d'une étape spécifique.

get_underlying_data_module()

Obtenez le module de données encapsulé sous-jacent.

Retours : pl. LightningDataModule — Le module de données d'origine qui a été encapsulé

state_dict()

Obtenez le dictionnaire d'état du MMAP DataModule pour les points de contrôle.

Renvoie : dict — Dictionnaire contenant les longueurs des chargeurs de données mis en cache

load_state_dict(state_dict)

Chargez le dictionnaire d'état pour restaurer l' DataModule état du MMAP.

Propriétés

data_sampler

Exposez l'échantillonneur de données du module de données sous-jacent au NeMo framework.

Renvoie : object ou None — L'échantillonneur de données du module de données sous-jacent

Exemple

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)

Remarques