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

Une autre surcharge liée au redémarrage est due au chargement des données : le cluster d'entraînement 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 résoudre ce problème, nous introduisons le chargeur de données MMAP DataLoader (Memory Mapped), qui met en cache les lots préextraits 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 nécessitant 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éextraits prêts à être utilisés immédiatement.

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

Grâce au cache, le job de formation bénéficiera des avantages suivants :

Configurations MMAP

Pour utiliser MMAP, il suffit de transmettre le 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 TP de rang 0 par nœud extrait les données de la source, tandis que les autres nœuds du même groupe de réplication de données lisent les données du cache partagé, éliminant ainsi les transferts redondants.

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

Consultez l'exemple d'activation du 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é du chargeur de données MMAP (cache-resume memory mappé) 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 l'entraînement après un échec 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

ValueErrorDéclenche si le paramètre de l'étape 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) à des formations existantes pour un entraînement sans point de contrôle. DataModules

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

Parameters

Attributs

Méthodes

setup(stage=None)

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

train_dataloader()

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

Retours : DataLoader — Entraînement intégré au MMAP DataLoader avec fonctionnalités de mise en cache et de prélecture

val_dataloader()

Créez la validation DataLoader avec un encapsulage MMAP.

Renvoie : DataLoader — Validation DataLoader encapsulée dans MMAP 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 None — Test DataLoader à partir du module de données sous-jacent, ou None 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édire 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 le point 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