Accelerate documentation

DataLoaders, Optimizers et Schedulers

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DataLoaders, Optimizers et Schedulers

Les classes internes utilisées par Accelerate pour préparer les objets à l’entraînement distribué lors de l’appel de prepare().

Utilitaires de DataLoader

accelerate.data_loader.prepare_data_loader

< >

( dataloader: DataLoaderdevice: torch.device | None = Nonenum_processes: int | None = Noneprocess_index: int | None = Nonesplit_batches: bool = Falseput_on_device: bool = Falserng_types: list[str | accelerate.utils.dataclasses.RNGType] | None = Nonedispatch_batches: bool | None = Noneeven_batches: bool = Trueslice_fn_for_dispatch: typing.Callable | None = Noneuse_seedable_sampler: bool = Falsedata_seed: int | None = Nonenon_blocking: bool = Falseuse_stateful_dataloader: bool = Falsetorch_device_mesh = None ) → torch.utils.data.dataloader.DataLoader

Paramètres

  • dataloader (torch.utils.data.dataloader.DataLoader) — Le chargeur de données à répartir sur plusieurs appareils.
  • device (torch.device) — L'appareil cible pour le DataLoader retourné.
  • num_processes (int, facultatif) — Le nombre de processus exécutés simultanément. La valeur par défaut est celle fournie par PartialState.
  • process_index (int, facultatif) — L'index du processus actuel. Par défaut, la valeur est celle fournie par PartialState.
  • split_batches (bool, optional, defaults to False) — Whether the resulting DataLoader should split the batches of the original data loader across devices or yield full batches (in which case it will yield batches starting at the process_index-th and advancing of num_processes batches at each iteration).

    Une autre façon de voir les choses est que la taille de lot observée sera identique à celle du dataloader initial si cette option est définie sur True, et égale à la taille de lot du dataloader initial multipliée par num_processes dans le cas contraire.

    Définir cette option sur True exige que la taille du lot du dataloader soit un multiple entier de batch_size.

  • put_on_device (bool, facultatif, par défaut False) — Indique s'il faut placer les lots sur device (ne fonctionne que si les lots sont des listes imbriquées, des tuples ou des dictionnaires de tenseurs).
  • rng_types (liste de str ou RNGType) — La liste des générateurs de nombres aléatoires à synchroniser au début de chaque itération. Doit être un ou plusieurs des éléments suivants :
    • "torch" : le générateur de nombres aléatoires de base de torch
    • "cuda" : le générateur de nombres aléatoires CUDA (GPU uniquement)
    • Le type de périphérique de tout accélérateur PyTorch enregistré : son générateur de nombres aléatoires de périphérique.
    • "xla" : le générateur de nombres aléatoires XLA (TPU uniquement)
    • "generator" : le torch.Generator du sampler (ou du batch sampler s’il n’y a pas de sampler dans votre dataloader) ou de l’ensemble de données itérable (s’il existe) si l’ensemble de données sous-jacent est de ce type.
  • dispatch_batches (bool, facultatif) — Si défini sur True, le dataloader préparé n'est itéré que sur le processus principal, puis les lots sont divisés et diffusés à chaque processus. La valeur par défaut est True si le jeu de données sous-jacent est un IterableDataset, False sinon.
  • even_batches (bool, facultatif, valeur par défaut True) — Si défini sur True, lorsque la taille totale du lot sur l’ensemble des processus ne divise pas exactement le jeu de données, les échantillons situés au début du jeu de données sont dupliqués afin que le lot puisse être réparti également entre tous les travailleurs.
  • slice_fn_for_dispatch (Callable, optional) -- If passed, this function will be used to slice tensors across num_processes. Will default to [slice_tensors()](/docs/accelerate/v1.16.0/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when dispatch_batchesis set toTrue` and will be ignored otherwise.
  • use_seedable_sampler (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser SeedableRandomSampler plutôt qu'un RandomSampler pour une meilleure reproductibilité. Cela peut entraîner des performances différentes en raison d'algorithmes de mélange différents, mais garantit que les résultats seront exactement identiques. Doit être associé à set_seed() à chaque self.set_epoch
  • data_seed (int, facultatif, par défaut None) — La graine à utiliser pour le générateur sous-jacent lors de l'utilisation de use_seedable_sampler. Si None, le générateur utilisera la graine par défaut actuelle de torch.
  • non_blocking (bool, facultatif, valeur par défaut False) — Si défini sur True, le dataloader utilisera des transferts hôte-vers-appareil non bloquants. Si le dataloader a pin_memory défini sur True, cela aidera à augmenter le chevauchement entre le transfert de données et les calculs.
  • use_stateful_dataloader (bool, facultatif, valeur par défaut False) — « Si défini sur true, le dataloader préparé par l’Accelerator sera basé sur torchdata.StatefulDataLoader. Cela nécessite l’installation de torchdata version 0.8.0 ou supérieure, qui prend en charge StatefulDataLoader. »
  • torch_device_mesh (torch.distributed.DeviceMesh, facultatif, par défaut None) — Mesh de dispositifs PyTorch.

Retourne

torch.utils.data.dataloader.DataLoader

Un nouveau chargeur de données qui produira la portion des lots

Enveloppe un DataLoader PyTorch pour générer des lots destinés à un seul des processus.

Selon la valeur de l’attribut drop_last du dataloader transmis, l’itération s’arrêtera au premier lot trop petit / absent sur tous les processus, ou bien elle recommencera depuis le début avec les indices.

Les BatchSampler avec des tailles de lot variables ne sont pas activés par défaut. Pour activer ce comportement, définissez even_batches sur False.

accelerate.skip_first_batches

< >

( dataloadernum_batches = 0 )

Crée un torch.utils.data.DataLoader qui sautera efficacement les num_batches premiers lots. Ne doit pas être utilisé si le dataloader d'origine est un StatefulDataLoader.

BatchSamplerShard

classe accelerate.data_loader.BatchSamplerShard

< >

( batch_sampler: BatchSamplernum_processes: int = 1process_index: int = 0split_batches: bool = Falseeven_batches: bool = True )

Paramètres

  • batch_sampler (torch.utils.data.sampler.BatchSampler) — Le batch sampler à diviser en plusieurs shards.
  • num_processes (int, facultatif, valeur par défaut 1) — Le nombre de processus exécutés simultanément.
  • process_index (int, facultatif, valeur par défaut 0) — L'index du processus actuel.
  • split_batches (bool, facultatif, par défaut False) — Indique si les shards doivent être créés en divisant un lot pour en attribuer une partie à chaque processus, ou en produisant des lots complets différents sur chaque processus.

    Sur deux processus avec un échantillonneur de [[0, 1, 2, 3], [4, 5, 6, 7]], cela donnera :

    • le sampler sur le processus 0 à produire [0, 1, 2, 3] et le sampler sur le processus 1 à produire [4, 5, 6, 7] si ce paramètre est défini sur False.
    • le sampler sur le processus 0 à produire [0, 1] puis [4, 5] et le sampler sur le processus 1 à produire [2, 3] puis [6, 7] si cet argument est défini sur True.
  • even_batches (bool, facultatif, par défaut True) — Indique s'il faut revenir au début du sampler lorsque le nombre d'échantillons n'est pas un multiple entier de (taille de lot d'origine / nombre de processus).

Enveloppe un BatchSampler PyTorch afin de générer des lots pour un seul des processus. Les instances de cette classe produisent toujours un nombre de lots qui est un multiple entier de num_processes et qui sont tous de la même taille. En fonction de la valeur de l'attribut drop_last du batch sampler transmis, l'itération s'arrête soit au premier lot qui serait trop petit / absent sur tous les processus, soit elle boucle en reprenant les indices depuis le début.

Les BatchSampler avec des tailles de lot variables ne sont pas activés par défaut. Pour activer ce comportement, définissez even_batches sur False.

IterableDatasetShard

classe accelerate.data_loader.IterableDatasetShard

< >

( dataset: IterableDatasetbatch_size: int = 1drop_last: bool = Falsenum_processes: int = 1process_index: int = 0split_batches: bool = False )

Paramètres

  • dataset (torch.utils.data.dataset.IterableDataset) — Le batch sampler à diviser en plusieurs shards.
  • batch_size (int, facultatif, par défaut 1) — La taille des lots par shard (si split_batches=False) ou la taille des lots (si split_batches=True).
  • drop_last (bool, facultatif, valeur par défaut False) — Indique s'il faut supprimer le dernier lot incomplet ou compléter les derniers lots en utilisant les échantillons du début.
  • num_processes (int, facultatif, valeur par défaut 1) — Le nombre de processus exécutés simultanément.
  • process_index (int, facultatif, valeur par défaut 0) — L'index du processus actuel.
  • split_batches (bool, facultatif, défaut sur False) — Indique si les shards doivent être créés en divisant un batch pour en attribuer une partie à chaque processus, ou en produisant des batches complets différents sur chaque processus.

    Sur deux processus avec un jeu de données itérable produisant [0, 1, 2, 3, 4, 5, 6, 7], cela donnera :

    • le shard sur le processus 0 pour produire [0, 1, 2, 3] et le shard sur le processus 1 pour produire [4, 5, 6, 7] si cet argument est défini sur False.
    • le shard sur le processus 0 pour produire [0, 1, 4, 5] et le sampler sur le processus 1 pour produire [2, 3, 6, 7] si ce paramètre est défini sur True.

Enveloppe un IterableDataset PyTorch afin de générer des échantillons pour un seul des processus. Les instances de cette classe produisent toujours un nombre d'échantillons qui est un multiple entier de la taille de lot effective (selon la valeur de split_batches, il s'agit soit de batch_size, soit de batch_size x num_processes). En fonction de la valeur de l'attribut drop_last du batch sampler transmis, l'itération s'arrête soit au premier lot qui serait trop petit, soit en bouclant avec les indices depuis le début.

DataLoaderShard

classe accelerate.data_loader.DataLoaderShard

< >

( datasetdevice = Nonerng_types = Nonesynchronized_generator = Noneskip_batches = 0use_stateful_dataloader = False_drop_last: bool = False_non_blocking: bool = Falsetorch_device_mesh = Noneiteration = 0**kwargs )

Paramètres

  • dataset (torch.utils.data.dataset.Dataset) — Le jeu de données à utiliser pour construire ce chargeur de données.
  • device (torch.device, facultatif) — Si fourni, l’appareil sur lequel placer tous les lots.
  • rng_types (liste de str ou RNGType) — La liste des générateurs de nombres aléatoires à synchroniser au début de chaque itération. Doit être un ou plusieurs des éléments suivants :
    • "torch" : le générateur de nombres aléatoires de base de torch
    • "cuda" : le générateur de nombres aléatoires CUDA (GPU uniquement)
    • Le type de périphérique de tout accélérateur PyTorch enregistré : son générateur de nombres aléatoires de périphérique.
    • "xla" : le générateur de nombres aléatoires XLA (TPU uniquement)
    • "generator" : un torch.Generator facultatif
  • synchronized_generator (torch.Generator, facultatif) — Un générateur de nombres aléatoires à maintenir synchronisé entre les processus.
  • skip_batches (int, facultatif, valeur par défaut 0) — Le nombre de lots à ignorer au début.
  • use_stateful_dataloader (bool, facultatif, valeur par défaut False) — Indique si cette classe doit adapter StatefulDataLoader de torchdata plutôt que le DataLoader standard.
  • **kwargs (arguments de mot-clé supplémentaires, facultatif) — Tous les autres arguments de mot-clé à passer à l'initialisation régulière de DataLoader.

Sous-classe de DataLoaderAdapter qui gère le placement sur les appareils et la configuration distribuée actuelle.

Attributs disponibles :

  • total_batch_size (int) — Taille de lot totale du chargeur de données sur tous les processus. Égale à la taille de lot d'origine lorsque split_batches=True ; sinon, la taille de lot d'origine * le nombre total de processus

  • total_dataset_length (int) — Longueur totale du jeu de données interne sur tous les processus.

DataLoaderDispatcher

classe accelerate.data_loader.DataLoaderDispatcher

< >

( datasetsplit_batches: bool = Falseskip_batches = 0use_stateful_dataloader = False_drop_last: bool = False_non_blocking: bool = Falseslice_fn = Nonetorch_device_mesh = Noneiteration = 0**kwargs )

Paramètres

  • split_batches (bool, facultatif, valeur par défaut False) — Indique si le DataLoader résultant doit répartir les lots du chargeur de données d’origine entre les différents appareils ou s’il doit produire des lots complets (dans ce cas, il produira des lots en commençant par le process_index-ième et en avançant de num_processes lots à chaque itération). Une autre façon de voir les choses est que la taille de lot observée sera identique à celle du dataloader initial si cette option est définie sur True, et égale à la taille de lot du dataloader initial multipliée par num_processes dans le cas contraire. Définir cette option sur True exige que la taille de lot du dataloader soit un multiple entier de batch_size.
  • skip_batches (int, facultatif, valeur par défaut 0) — Le nombre de lots à ignorer au début d'une itération.
  • use_stateful_dataloader (bool, facultatif, valeur par défaut False) — Indique si cette classe doit adapter StatefulDataLoader de torchdata plutôt que le DataLoader standard.

Sous-classe de DataLoaderAdapter qui itère et prétraite uniquement sur le processus 0, puis distribue à chaque processus sa partie du lot.

Attributs disponibles :

  • total_batch_size (int) — Taille de lot totale du chargeur de données sur tous les processus. Égale à la taille de lot d'origine lorsque split_batches=True ; sinon, la taille de lot d'origine * le nombre total de processus

  • total_dataset_length (int) — Longueur totale du jeu de données interne sur tous les processus.

AcceleratedOptimizer

classe accelerate.optimizer.AcceleratedOptimizer

< >

( optimizerdevice_placement = Truescaler = None )

Paramètres

  • optimizer (torch.optim.optimizer.Optimizer) — L’optimiseur à encapsuler.
  • device_placement (bool, facultatif, par défaut True) — Indique si l'optimiseur doit gérer le placement sur les appareils. Si c'est le cas, il placera le dictionnaire d'état de optimizer sur l'appareil approprié.
  • scaler (torch.amp.GradScaler ou torch.cuda.amp.GradScaler, facultatif) — Le scaler à utiliser dans la fonction step lors de l’entraînement avec précision mixte.

Enveloppe interne autour d'un optimiseur torch.

Conditionnellement, exécute step et zero_grad si les gradients doivent être synchronisés lors de l'accumulation des gradients.

eval

< >

( )

Définit l'optimiseur en mode « eval ». Utile pour des optimiseurs comme schedule_free

train

< >

( )

Définit l'optimiseur en mode « train ». Utile pour des optimiseurs comme schedule_free

AcceleratedScheduler

classe accelerate.scheduler.AcceleratedScheduler

< >

( scheduleroptimizersstep_with_optimizer: bool = Truesplit_batches: bool = False )

Paramètres

  • scheduler (torch.optim.lr_scheduler._LRScheduler) — Le planificateur à encapsuler.
  • optimizers (un ou une liste de torch.optim.Optimizer) — Les optimiseurs utilisés.
  • step_with_optimizer (bool, facultatif, par défaut True) — Indique si le planificateur doit être incrémenté à chaque étape de l'optimiseur.
  • split_batches (bool, facultatif, valeur par défaut False) — Indique si les dataloaders répartissent un lot sur les différents processus (la taille du lot reste donc identique quel que soit le nombre de processus) ou s'ils créent des lots sur chaque processus (la taille du lot est alors la taille du lot d'origine multipliée par le nombre de processus).

Un wrapper autour d'un planificateur de taux d'apprentissage qui n'effectuera un pas que lorsque les optimiseurs ont effectué un pas d'entraînement. Utile pour éviter qu'un planificateur n'avance trop rapidement lorsque les gradients ont débordé et qu'aucun pas d'entraînement n'a eu lieu (en entraînement en précision mixte)

Lors de l’exécution d’une accumulation de gradients, les longueurs du planificateur ne doivent pas être modifiées en conséquence : Accelerate effectuera toujours un pas du planificateur pour en tenir compte.

Update on GitHub