Accelerate documentation
DataLoaders, Optimizers et Schedulers
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
< source >( 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 leDataLoaderretourné. - 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 toFalse) — Whether the resultingDataLoadershould split the batches of the original data loader across devices or yield full batches (in which case it will yield batches starting at theprocess_index-th and advancing ofnum_processesbatches at each iteration).Une autre façon de voir les choses est que la taille de lot observée sera identique à celle du
dataloaderinitial si cette option est définie surTrue, et égale à la taille de lot dudataloaderinitial multipliée parnum_processesdans le cas contraire.Définir cette option sur
Trueexige que la taille du lot dudataloadersoit un multiple entier debatch_size. - put_on_device (
bool, facultatif, par défautFalse) — Indique s'il faut placer les lots surdevice(ne fonctionne que si les lots sont des listes imbriquées, des tuples ou des dictionnaires de tenseurs). - rng_types (liste de
strou 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": letorch.Generatordu 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 surTrue, 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 estTruesi le jeu de données sous-jacent est unIterableDataset,Falsesinon. - even_batches (
bool, facultatif, valeur par défautTrue) — Si défini surTrue, 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 acrossnum_processes. Will default to [slice_tensors()](/docs/accelerate/v1.16.0/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only whendispatch_batchesis set toTrue` and will be ignored otherwise. - use_seedable_sampler (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliserSeedableRandomSamplerplutôt qu'unRandomSamplerpour 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()à chaqueself.set_epoch - data_seed (
int, facultatif, par défautNone) — La graine à utiliser pour le générateur sous-jacent lors de l'utilisation deuse_seedable_sampler. SiNone, le générateur utilisera la graine par défaut actuelle de torch. - non_blocking (
bool, facultatif, valeur par défautFalse) — Si défini surTrue, le dataloader utilisera des transferts hôte-vers-appareil non bloquants. Si le dataloader apin_memorydéfini surTrue, cela aidera à augmenter le chevauchement entre le transfert de données et les calculs. - use_stateful_dataloader (
bool, facultatif, valeur par défautFalse) — « Si défini sur true, le dataloader préparé par l’Accelerator sera basé sur torchdata.StatefulDataLoader. Cela nécessite l’installation detorchdataversion 0.8.0 ou supérieure, qui prend en charge StatefulDataLoader. » - torch_device_mesh (
torch.distributed.DeviceMesh, facultatif, par défautNone) — 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
BatchSampleravec des tailles de lot variables ne sont pas activés par défaut. Pour activer ce comportement, définissezeven_batchessurFalse.
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
< source >( 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éfautFalse) — 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 surFalse. - 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 surTrue.
- le sampler sur le processus 0 à produire
- even_batches (
bool, facultatif, par défautTrue) — 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
BatchSampleravec des tailles de lot variables ne sont pas activés par défaut. Pour activer ce comportement, définissezeven_batchessurFalse.
IterableDatasetShard
classe accelerate.data_loader.IterableDatasetShard
< source >( 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 (sisplit_batches=False) ou la taille des lots (sisplit_batches=True). - drop_last (
bool, facultatif, valeur par défautFalse) — 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 surFalse) — 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 surFalse. - 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 surTrue.
- le shard sur le processus 0 pour produire
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
< source >( 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
strou 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": untorch.Generatorfacultatif
- 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éfautFalse) — Indique si cette classe doit adapterStatefulDataLoaderdetorchdataplutôt que leDataLoaderstandard. - **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 lorsquesplit_batches=True; sinon, la taille de lot d'origine * le nombre total de processustotal_dataset_length (
int) — Longueur totale du jeu de données interne sur tous les processus.
DataLoaderDispatcher
classe accelerate.data_loader.DataLoaderDispatcher
< source >( 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éfautFalse) — Indique si leDataLoaderré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 leprocess_index-ième et en avançant denum_processeslots à chaque itération). Une autre façon de voir les choses est que la taille de lot observée sera identique à celle dudataloaderinitial si cette option est définie surTrue, et égale à la taille de lot dudataloaderinitial multipliée parnum_processesdans le cas contraire. Définir cette option surTrueexige que la taille de lot dudataloadersoit un multiple entier debatch_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éfautFalse) — Indique si cette classe doit adapterStatefulDataLoaderdetorchdataplutôt que leDataLoaderstandard.
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 lorsquesplit_batches=True; sinon, la taille de lot d'origine * le nombre total de processustotal_dataset_length (
int) — Longueur totale du jeu de données interne sur tous les processus.
AcceleratedOptimizer
classe accelerate.optimizer.AcceleratedOptimizer
< source >( optimizerdevice_placement = Truescaler = None )
Paramètres
- optimizer (
torch.optim.optimizer.Optimizer) — L’optimiseur à encapsuler. - device_placement (
bool, facultatif, par défautTrue) — Indique si l'optimiseur doit gérer le placement sur les appareils. Si c'est le cas, il placera le dictionnaire d'état deoptimizersur l'appareil approprié. - scaler (
torch.amp.GradScaleroutorch.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.
Définit l'optimiseur en mode « eval ». Utile pour des optimiseurs comme schedule_free
Définit l'optimiseur en mode « train ». Utile pour des optimiseurs comme schedule_free
AcceleratedScheduler
classe accelerate.scheduler.AcceleratedScheduler
< source >( 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éfautTrue) — Indique si le planificateur doit être incrémenté à chaque étape de l'optimiseur. - split_batches (
bool, facultatif, valeur par défautFalse) — 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.