Hugging Face's logo

Accelerate documentation

Accélérateur

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Accélérateur

La classe Accelerator est la principale pour activer l'entraînement distribué sur tout type de configuration d'entraînement. Consultez le tutoriel Ajouter Accelerator à votre code pour en savoir plus sur l'ajout de Accelerator à votre script.

Accélérateur

classe accelerate.Accelerator

< >

( device_placement: bool = Truesplit_batches: bool = <object object at 0x7f8c18e61580>mixed_precision: PrecisionType | str | None = Nonegradient_accumulation_steps: int = 1cpu: bool = Falsedataloader_config: DataLoaderConfiguration | None = Nonedeepspeed_plugin: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = Nonefsdp_plugin: FullyShardedDataParallelPlugin | None = Nonetorch_tp_plugin: TorchTensorParallelPlugin | None = Nonemegatron_lm_plugin: MegatronLMPlugin | None = Nonerng_types: list[str | RNGType] | None = Nonelog_with: str | LoggerType | GeneralTracker | list[str | LoggerType | GeneralTracker] | None = Noneproject_dir: str | os.PathLike | None = Noneproject_config: ProjectConfiguration | None = Nonegradient_accumulation_plugin: GradientAccumulationPlugin | None = Nonestep_scheduler_with_optimizer: bool = Truekwargs_handlers: list[KwargsHandler] | None = Nonedynamo_backend: DynamoBackend | str | None = Nonedynamo_plugin: TorchDynamoPlugin | None = Nonedeepspeed_plugins: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = Noneparallelism_config: ParallelismConfig | None = None )

Paramètres

  • device_placement (bool, facultatif, par défaut True) — Indique si l'accélérateur doit placer les objets sur l'appareil (tenseurs générés par le chargeur de données, modèle, etc…).
  • mixed_precision (str, facultatif) — Indique s'il faut utiliser l'entraînement en précision mixte. Choisissez parmi ‘no’,‘fp16’,‘bf16’ ou ‘fp8’. Par défaut, la valeur de la variable d'environnement ACCELERATE_MIXED_PRECISION est utilisée, qui utilise la valeur par défaut de la configuration accelerate du système actuel ou le drapeau passé avec la commande accelerate.launch. ‘fp8’ nécessite l'installation de transformers-engine.
  • gradient_accumulation_steps (int, facultatif, valeur par défaut 1) — Le nombre d'étapes qui doivent s'écouler avant que les gradients ne soient accumulés. Une valeur > 1 doit être combinée avec Accelerator.accumulate. Si elle n'est pas fournie, la valeur de la variable d'environnement ACCELERATE_GRADIENT_ACCUMULATION_STEPS sera utilisée par défaut. Elle peut également être configurée via un GradientAccumulationPlugin.
  • cpu (bool, facultatif) — Indique s'il faut forcer l'exécution du script sur le CPU. Si défini sur True, ignore le GPU disponible et force l'exécution sur un seul processus.
  • dataloader_config (DataLoaderConfiguration, facultatif) — Une configuration pour la gestion des dataloaders dans les scénarios distribués.
  • deepspeed_plugin (DeepSpeedPlugin ou dict de str — DeepSpeedPlugin, facultatif) : Ajustez vos arguments liés à DeepSpeed à l’aide de cet argument. Cet argument est facultatif et peut être configuré directement à l’aide de accelerate config. En cas d’utilisation de plusieurs plugins, utilisez la propriété key configurée de chaque plugin pour y accéder via accelerator.state.get_deepspeed_plugin(key). Alias de deepspeed_plugins.
  • fsdp_plugin (FullyShardedDataParallelPlugin, facultatif) — Ajustez vos arguments liés à FSDP à l'aide de cet argument. Cet argument est facultatif et peut être configuré directement à l'aide de accelerate config
  • torch_tp_plugin (TorchTensorParallelPlugin, facultatif) — Obsolète : utilisez parallelism_config avec tp_size à la place.
  • megatron_lm_plugin (MegatronLMPlugin, facultatif) — Ajustez vos arguments liés à MegatronLM à l’aide de cet argument. Cet argument est facultatif et peut être configuré directement à l’aide de accelerate config
  • 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 de vos dataloaders préparés. 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)
    • "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.

    Par défaut, la valeur sera ["torch"] pour les versions de PyTorch <=1.5.1 et ["generator"] pour les versions de PyTorch >= 1.6.

  • log_with (liste de str, LoggerType ou GeneralTracker, facultatif) — Une liste de loggers à configurer pour le suivi des expériences. Doit être un ou plusieurs des éléments suivants :
    • "all"
    • "tensorboard"
    • "wandb"
    • "trackio"
    • "aim"
    • "comet_ml"
    • "mlflow"
    • "dvclive"
    • "swanlab" Si "all" est sélectionné, tous les traceurs disponibles dans l’environnement seront récupérés et initialisés. Il est également possible d’accepter des implémentations de GeneralTracker pour des traceurs personnalisés, et de les combiner avec "all".
  • project_config (ProjectConfiguration, facultatif) — Une configuration pour la gestion de la sauvegarde de l'état.
  • project_dir (str, os.PathLike, facultatif) — Un chemin vers un répertoire pour stocker des données telles que les journaux des enregistreurs compatibles localement et, le cas échéant, les points de contrôle enregistrés.
  • step_scheduler_with_optimizer (bool, facultatif, valeur par défaut True) — Définir True si le planificateur de taux d’apprentissage est incrémenté en même temps que l’optimiseur, False si cela n’est fait que dans certaines circonstances (à la fin de chaque époque, par exemple).
  • kwargs_handlers (liste de KwargsHandler, facultatif) — Une liste de KwargsHandler pour personnaliser la création des objets liés à l’entraînement distribué, au profilage ou à la précision mixte. Voir kwargs pour plus d’informations.
  • dynamo_backend (str ou DynamoBackend, facultatif, par défaut "no") — Définissez l’un des backends dynamo possibles pour optimiser votre entraînement avec torch dynamo.
  • dynamo_plugin (TorchDynamoPlugin, facultatif) — Une configuration pour la gestion de torch dynamo, si des ajustements plus poussés que le simple backend ou mode sont nécessaires.
  • gradient_accumulation_plugin (GradientAccumulationPlugin, facultatif) — Une configuration pour la gestion de l’accumulation des gradients, si des ajustements plus poussés que le simple paramètre gradient_accumulation_steps sont nécessaires.

Crée une instance d'accélérateur pour l'entraînement distribué ou l'entraînement en précision mixte.

Attributs disponibles :

  • device (torch.device) — L'appareil à utiliser.
  • distributed_type (DistributedType) — La configuration d’entraînement distribué.
  • local_process_index (int) — L'index du processus sur la machine actuelle.
  • mixed_precision (str) — Le mode de précision mixte configuré.
  • num_processes (int) — Le nombre total de processus utilisés pour l'entraînement.
  • optimizer_step_was_skipped (bool) — Indique si la mise à jour de l’optimiseur a été ignorée (en raison d’un dépassement de gradient en précision mixte), auquel cas le taux d’apprentissage ne doit pas être modifié.
  • process_index (int) — L'index global du processus actuel parmi tous les processus.
  • state (AcceleratorState) — L'état de la configuration distribuée.
  • sync_gradients (bool) — Indique si les gradients sont actuellement synchronisés entre tous les processus.
  • use_distributed (bool) — Indique si la configuration actuelle est destinée à l'entraînement distribué.

accumulate

< >

( *models )

Paramètres

  • *models (liste de torch.nn.Module) — Modules PyTorch préparés avec Accelerator.prepare. Les modèles passés à accumulate() ignoreront la synchronisation des gradients lors de la rétropropagation en entraînement distribué

Un gestionnaire de contexte qui enveloppe légèrement et effectue l'accumulation des gradients automatiquement

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=1)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)

>>> for input, output in dataloader:
...     with accelerator.accumulate(model):
...         outputs = model(input)
...         loss = loss_func(outputs)
...         loss.backward()
...         optimizer.step()
...         scheduler.step()
...         optimizer.zero_grad()

autocast

< >

( autocast_handler: AutocastKwargs = None )

Appliquera la précision mixte automatique à l'intérieur du bloc dans ce gestionnaire de contexte, si elle est activée. Rien de différent ne se produira sinon.

Un autocast_handler différent peut être transmis pour remplacer celui défini dans l'objet Accelerator. Cela est utile dans les blocs sous autocast où vous souhaitez revenir au fp32.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(mixed_precision="fp16")
>>> with accelerator.autocast():
...     train()

backward

< >

( loss**kwargs )

Échelle les gradients conformément au GradientAccumulationPlugin et appelle le backward() approprié en fonction de la configuration.

Doit être utilisé à la place de loss.backward().

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> outputs = model(inputs)
>>> loss = loss_fn(outputs, labels)
>>> accelerator.backward(loss)

check_trigger

< >

( )

Vérifie si le tenseur de déclenchement interne a été défini à 1 dans l'un des processus. Si c'est le cas, renvoie True et réinitialise le tenseur de déclenchement à 0.

Note : N'exige pas wait_for_everyone()

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume later in the training script
>>> # `should_do_breakpoint` is a custom function to monitor when to break,
>>> # e.g. when the loss is NaN
>>> if should_do_breakpoint(loss):
...     accelerator.set_trigger()
>>> # Assume later in the training script
>>> if accelerator.check_trigger():
...     break

clear

< >

( *objects )

Alias de Accelerate.free_memory, libère toutes les références aux objets internes stockés et appelle le collecteur de déchets. Vous devez appeler cette méthode entre deux entraînements avec des modèles/optimiseurs différents.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, scheduler = ...
>>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
>>> model, optimizer, scheduler = accelerator.clear(model, optimizer, scheduler)

clip_grad_norm_

< >

( parametersmax_normnorm_type = 2 ) → torch.Tensor

Retourne

torch.Tensor

Norme totale des gradients des paramètres (considérés comme un seul vecteur).

Doit être utilisé à la place de torch.nn.utils.clip_grad_norm_.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)

>>> for input, target in dataloader:
...     optimizer.zero_grad()
...     output = model(input)
...     loss = loss_func(output, target)
...     accelerator.backward(loss)
...     if accelerator.sync_gradients:
...         accelerator.clip_grad_norm_(model.parameters(), max_grad_norm)
...     optimizer.step()

clip_grad_value_

< >

( parametersclip_value )

Doit être utilisé à la place de torch.nn.utils.clip_grad_value_.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)

>>> for input, target in dataloader:
...     optimizer.zero_grad()
...     output = model(input)
...     loss = loss_func(output, target)
...     accelerator.backward(loss)
...     if accelerator.sync_gradients:
...         accelerator.clip_grad_value_(model.parameters(), clip_value)
...     optimizer.step()

deepspeed_ulysses_dl_adapter

< >

( dlmodel )

Ceci est normalement appelé dans le cadre de prepare, mais lorsque le dataloader a été préparé séparément du modèle (pour l'appel externe accelerator.prepare), cet appel supplémentaire doit être effectué après prepare(model) (voir HF Trainer comme cas d'utilisation).

end_training

< >

( )

Exécute les comportements spéciaux de fin d’entraînement, tels que l’arrêt des traceurs uniquement sur le processus principal ou la destruction du groupe de processus. Doit toujours être appelé à la fin de votre script si vous utilisez le suivi d’expériences.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(log_with="tensorboard")
>>> accelerator.init_trackers("my_project")
>>> # Do training
>>> accelerator.end_training()

free_memory

< >

( *objects )

Libérera toutes les références aux objets internes stockés et appellera le collecteur de déchets. Vous devez appeler cette méthode entre deux entraînements avec des modèles/optimiseurs différents. Réinitialisera également Accelerator.step à 0.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, scheduler = ...
>>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
>>> model, optimizer, scheduler = accelerator.free_memory(model, optimizer, scheduler)

gather

< >

( tensor ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

Paramètres

  • tensor (torch.Tensor, ou un tuple/liste/dictionnaire imbriqué de torch.Tensor) — Les tenseurs à collecter sur tous les processus.

Retourne

torch.Tensor, ou un tuple/liste/dictionnaire imbriqué de torch.Tensor

Le(s) tenseur(s) collecté(s). Notez que la première dimension du résultat est num_processes multipliée par la première dimension des tenseurs d'entrée.

Rassemble les valeurs de tensor sur tous les processus et les concatène sur la première dimension. Utile pour regrouper les prédictions de tous les processus lors de l'évaluation.

Note : Cette opération de regroupement s'effectue dans tous les processus.

Exemple :

>>> # Assuming four processes
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> process_tensor = torch.tensor([accelerator.process_index], device=accelerator.device)
>>> gathered_tensor = accelerator.gather(process_tensor)
>>> gathered_tensor
tensor([0, 1, 2, 3])

gather_for_metrics

< >

( input_datause_gather_object = False )

Paramètres

  • input_data (torch.Tensor, object, un tuple/liste/dictionnaire imbriqué de torch.Tensor, ou un tuple/liste/dictionnaire imbriqué de object) — Les tenseurs ou objets pour le calcul des métriques sur tous les processus
  • use_gather_object(bool) — Indique s'il faut forcer l'utilisation de gather_object au lieu de gather (ce qui est déjà le cas si aucun des objets transmis ne contient de tenseurs). Ce drapeau peut être utile pour regrouper des tenseurs de tailles différentes que l'on ne souhaite ni compléter (padding) ni concaténer le long de la première dimension. Son utilisation avec des tenseurs GPU est mal prise en charge et inefficace, car elle entraîne un transfert GPU -> CPU, les tenseurs devant être sérialisés (pickled).

Réunit input_data et supprime éventuellement les doublons dans le dernier lot si le système est distribué. Doit être utilisé pour rassembler les entrées et les cibles en vue du calcul des métriques.

Exemple :

>>> # Assuming two processes, with a batch size of 5 on a dataset with 9 samples
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader = torch.utils.data.DataLoader(range(9), batch_size=5)
>>> dataloader = accelerator.prepare(dataloader)
>>> batch = next(iter(dataloader))
>>> gathered_items = accelerator.gather_for_metrics(batch)
>>> len(gathered_items)
9

get_state_dict

< >

( modelunwrap = True ) → dict

Paramètres

  • model (torch.nn.Module) — Un modèle PyTorch passé par Accelerator.prepare()
  • unwrap (bool, facultatif, par défaut True) — Indique s'il faut retourner le state_dict sous-jacent original de model ou le state_dict encapsulé

Retourne

dict

Le dictionnaire d'état du modèle, potentiellement sans précision complète.

Retourne le dictionnaire d'état d'un modèle transmis via Accelerator.prepare(), potentiellement sans pleine précision.

Exemple :

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> net = torch.nn.Linear(2, 2)
>>> net = accelerator.prepare(net)
>>> state_dict = accelerator.get_state_dict(net)

get_tracker

< >

( name: strunwrap: bool = False ) → GeneralTracker

Paramètres

  • name (str) — Le nom d’un tracker, correspondant à la propriété .name.
  • unwrap (bool) — Indique s'il faut retourner le mécanisme de suivi interne ou plutôt le tracker encapsulé (recommandé).

Retourne

GeneralTracker

Le traceur correspondant à name s'il existe.

Retourne un tracker depuis self.trackers en fonction de name, uniquement sur le processus principal.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(log_with="tensorboard")
>>> accelerator.init_trackers("my_project")
>>> tensorboard_tracker = accelerator.get_tracker("tensorboard")

join_uneven_inputs

< >

( joinableseven_batches = None )

Paramètres

  • joinables (list[torch.distributed.algorithms.Joinable]) — Une liste de modèles ou d’optimiseurs qui sous-classent torch.distributed.algorithms.Joinable. Le plus souvent, il s’agit d’un Module PyTorch préparé avec Accelerator.prepare pour l’entraînement DistributedDataParallel.
  • even_batches (bool, facultatif) — Si défini, cette valeur écrasera la valeur de even_batches définie dans le Accelerator. Si elle n’est pas fournie, la valeur par défaut du Accelerator sera utilisée.

Un gestionnaire de contexte qui facilite l’entraînement ou l’évaluation distribués sur des entrées inégales, agissant comme un wrapper autour de torch.distributed.algorithms.join. Cela est utile lorsque la taille totale du lot ne divise pas uniformément la longueur du jeu de données.

join_uneven_inputs n'est pris en charge que pour l'entraînement Distributed Data Parallel sur plusieurs GPU. Pour toute autre configuration, cette méthode n'aura aucun effet.

L'écrasement de even_batches n'affecte pas les chargeurs de données de type itérable.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(even_batches=True)
>>> ddp_model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

>>> with accelerator.join_uneven_inputs([ddp_model], even_batches=False):
...     for input, output in dataloader:
...         outputs = model(input)
...         loss = loss_func(outputs)
...         loss.backward()
...         optimizer.step()
...         optimizer.zero_grad()

load_state

< >

( input_dir: str | None = Noneload_kwargs: dict | None = None**load_model_func_kwargs )

Paramètres

  • input_dir (str ou os.PathLike) — Le nom du dossier dans lequel tous les poids et états pertinents ont été enregistrés. Peut être None si automatic_checkpoint_naming est utilisé, auquel cas le dernier point de contrôle sera sélectionné.
  • load_kwargs (dict, facultatif) — Arguments supplémentaires pour la fonction load sous-jacente, tels que les arguments facultatifs pour state_dict et optimizer.
  • load_model_func_kwargs (dict, facultatif) — Arguments supplémentaires par mot-clé pour le chargement du modèle, qui peuvent être transmis à la fonction de chargement sous-jacente, tels que les arguments facultatifs de la fonction load_checkpoint de DeepSpeed ou un map_location pour charger le modèle et l’optimiseur.

Charge les états actuels du modèle, de l'optimiseur, du scaler, des générateurs RNG et des objets enregistrés.

À n'utiliser qu'en conjonction avec Accelerator.save_state(). Si un fichier n'est pas enregistré pour le checkpointing, il ne sera pas chargé s'il est stocké dans le répertoire.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, lr_scheduler = ...
>>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
>>> accelerator.load_state("my_checkpoint")

local_main_process_first

< >

( )

Permet au processus principal local d'entrer dans un bloc with.

Les autres processus entreront dans le bloc with après la sortie du processus principal.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> with accelerator.local_main_process_first():
...     # This will be printed first by local process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {accelerator.local_process_index}")

lomo_backward

< >

( loss: torch.Tensorlearning_rate: float )

Exécute la passe arrière sur les optimiseurs LOMO.

main_process_first

< >

( )

Permet au processus principal de passer en premier dans un bloc with.

Les autres processus entreront dans le bloc with après la sortie du processus principal.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> with accelerator.main_process_first():
...     # This will be printed first by process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {accelerator.process_index}")

maybe_context_parallel

< >

( buffers: list[torch.Tensor] | None = Nonebuffer_seq_dims: list[int] | None = Noneno_restore_buffers: set[torch.Tensor] | None = None )

Paramètres

  • buffers (list[torch.Tensor], optional) — Buffers qui seront fractionnés le long de la dimension de séquence. Les exemples courants sont les entrées, les étiquettes ou les buffers d'embeddings positionnels. Ce gestionnaire de contexte modifiera ces buffers sur place, et après la sortie du contexte, les buffers seront restaurés à leur état d'origine. Pour éviter des restaurations inutiles, vous pouvez utiliser no_restore_buffers pour spécifier quels buffers n'ont pas besoin d'être restaurés.
  • buffer_seq_dims (list[int], optional) — Dimensions de séquence des buffers.
  • no_restore_buffers (set[torch.Tensor], optional) — Cet ensemble doit être un sous-ensemble de buffers. Il spécifie quels buffers de l'argument buffers ne seront pas restaurés après la sortie du contexte. Ces buffers seront alors conservés dans un état fragmenté.

Un gestionnaire de contexte qui permet l'entraînement parallèle par contexte.

context_parallel est actuellement pris en charge avec FSDP2 et nécessite parallelism_config.cp_size >

  1. Si l'une de ces conditions n'est pas remplie, ce gestionnaire de contexte n'aura aucun effet, bien qu'il ne lève pas d'Exception afin de limiter les modifications de code nécessaires.

Ce gestionnaire de contexte doit être recréé à chaque étape d’entraînement, comme le montre l’exemple ci-dessous.

Exemple :

>>> for batch in dataloader:
...     with accelerator.maybe_context_parallel(
...         buffers=[batch["input_ids"], batch["attention_mask"]],
...         buffer_seq_dims=[1, 1],
...         no_restore_buffers={batch["input_ids"]},
...     ):
...         outputs = model(batch)
...         ...

no_sync

< >

( model )

Paramètres

  • model (torch.nn.Module) — Module PyTorch préparé avec Accelerator.prepare

Un gestionnaire de contexte pour désactiver la synchronisation des gradients entre les processus DDP en appelant torch.nn.parallel.DistributedDataParallel.no_sync.

Si model n'est pas en DDP, ce gestionnaire de contexte ne fait rien

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
>>> input_a = next(iter(dataloader))
>>> input_b = next(iter(dataloader))

>>> with accelerator.no_sync():
...     outputs = model(input_a)
...     loss = loss_func(outputs)
...     accelerator.backward(loss)
...     # No synchronization across processes, only accumulate gradients
>>> outputs = model(input_b)
>>> accelerator.backward(loss)
>>> # Synchronization across all processes
>>> optimizer.step()
>>> optimizer.zero_grad()

on_last_process

< >

( function: Callable[..., Any] )

Paramètres

  • function (Callable) — La fonction à décorer.

Un décorateur qui exécute la fonction décorée uniquement sur le dernier processus. Peut également être appelé à l'aide de la classe PartialState.

Exemple :

# Assume we have 4 processes.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_last_process
def print_something():
    print(f"Printed on process {accelerator.process_index}")


print_something()
"Printed on process 3"

on_local_main_process

< >

( function: Callable[..., Any] | None = None )

Paramètres

  • function (Callable) — La fonction à décorer.

Un décorateur qui exécute la fonction décorée uniquement sur le processus principal local. Peut également être appelé à l'aide de la classe PartialState.

Exemple :

# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_local_main_process
def print_something():
    print("This will be printed by process 0 only on each server.")


print_something()
# On server 1:
"This will be printed by process 0 only"
# On server 2:
"This will be printed by process 0 only"

on_local_process

< >

( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )

Paramètres

  • function (Callable, facultatif) — La fonction à décorer.
  • local_process_index (int, facultatif) — L'index du processus local sur lequel exécuter la fonction.

Un décorateur qui exécute la fonction décorée uniquement sur un index de processus local donné. Peut également être appelé à l’aide de la classe PartialState.

Exemple :

# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_local_process(local_process_index=2)
def print_something():
    print(f"Printed on process {accelerator.local_process_index}")


print_something()
# On server 1:
"Printed on process 2"
# On server 2:
"Printed on process 2"

on_main_process

< >

( function: Callable[..., Any] | None = None )

Paramètres

  • function (Callable) — La fonction à décorer.

Un décorateur qui exécute la fonction décorée uniquement sur le processus principal. Peut également être appelé à l'aide de la classe PartialState.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()


>>> @accelerator.on_main_process
... def print_something():
...     print("This will be printed by process 0 only.")


>>> print_something()
"This will be printed by process 0 only"

on_process

< >

( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )

Paramètres

  • function (Callable, optional) — La fonction à décorer.
  • process_index (int, optional) — L'index du processus sur lequel exécuter la fonction.

Un décorateur qui exécute la fonction décorée uniquement sur un index de processus donné. Peut également être appelé à l'aide de la classe PartialState.

Exemple :

# Assume we have 4 processes.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_process(process_index=2)
def print_something():
    print(f"Printed on process {accelerator.process_index}")


print_something()
"Printed on process 2"

pad_across_processes

< >

( tensordim = 0pad_index = 0pad_first = False ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à collecter.
  • dim (int, facultatif, valeur par défaut 0) — La dimension sur laquelle effectuer le bourrage.
  • pad_index (int, facultatif, valeur par défaut 0) — La valeur utilisée pour le bourrage.
  • pad_first (bool, facultatif, par défaut False) — Indique s'il faut ajouter des jetons de bourrage au début ou à la fin.

Retourne

torch.Tensor, ou un tuple/liste/dictionnaire imbriqué de torch.Tensor

Le ou les tenseurs rembourrés.

Rembourrer récursivement les tenseurs d'une liste/tuple/dictionnaire imbriqué de tenseurs provenant de tous les appareils à la même taille afin qu'ils puissent être collectés en toute sécurité.

Exemple :

>>> # Assuming two processes, with the first processes having a tensor of size 1 and the second of size 2
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> process_tensor = torch.arange(accelerator.process_index + 1).to(accelerator.device)
>>> padded_tensor = accelerator.pad_across_processes(process_tensor)
>>> padded_tensor.shape
torch.Size([2])

prepare

< >

( *argsdevice_placement = None )

Paramètres

  • *args (liste d'objets) — L'un des types d'objets suivants :
    • torch.utils.data.DataLoader : Dataloader PyTorch
    • torch.nn.Module : Module PyTorch
    • torch.optim.Optimizer : Optimiseur PyTorch
    • torch.optim.lr_scheduler.LRScheduler : Planificateur de taux d'apprentissage PyTorch
  • device_placement (list[bool], facultatif) — Utilisé pour personnaliser si le placement automatique des appareils doit être effectué pour chaque objet transmis. Doit être une liste de la même longueur que args. Non compatible avec DeepSpeed ou FSDP.

Prépare tous les objets passés dans args pour l’entraînement distribué et la précision mixte, puis les renvoie dans le même ordre.

Vous n'avez pas besoin de préparer un modèle si vous l'utilisez uniquement pour l'inférence sans aucun type de précision mixte

Exemples :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model, optimizer, data_loader and scheduler are defined
>>> model, optimizer, data_loader, scheduler = accelerator.prepare(model, optimizer, data_loader, scheduler)
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model, optimizer, data_loader and scheduler are defined
>>> device_placement = [True, True, False, False]
>>> # Will place the first two items passed in automatically to the right device but not the last two.
>>> model, optimizer, data_loader, scheduler = accelerator.prepare(
...     model, optimizer, data_loader, scheduler, device_placement=device_placement
... )

prepare_data_loader

< >

( data_loader: torch.utils.data.DataLoaderdevice_placement = Noneslice_fn_for_dispatch = None )

Paramètres

  • data_loader (torch.utils.data.DataLoader) — Un DataLoader PyTorch standard pour préparer
  • device_placement (bool, facultatif) — Indique s'il faut placer les lots sur le bon appareil dans le chargeur de données préparé. La valeur par défaut est self.device_placement.
  • 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/main/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when dispatch_batchesis set toTrue` and will be ignored otherwise.

Prépare un DataLoader PyTorch pour l'entraînement dans toute configuration distribuée. Il est recommandé d'utiliser Accelerator.prepare() à la place.

Exemple :

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> data_loader = torch.utils.data.DataLoader(...)
>>> data_loader = accelerator.prepare_data_loader(data_loader, device_placement=True)

prepare_model

< >

( model: torch.nn.Moduledevice_placement: bool | None = Noneevaluation_mode: bool = False )

Paramètres

  • model (torch.nn.Module) — Un modèle PyTorch à préparer. Vous n’avez pas besoin de préparer un modèle s’il est utilisé uniquement pour l’inférence sans aucun type de précision mixte
  • device_placement (bool, facultatif) — Indique s'il faut placer le modèle sur le bon appareil. La valeur par défaut est self.device_placement.
  • evaluation_mode (bool, facultatif, par défaut False) — Indique s'il faut configurer le modèle uniquement pour l'évaluation, en appliquant simplement la précision mixte et torch.compile (si configuré dans l'objet Accelerator).

Prépare un modèle PyTorch pour l'entraînement dans toute configuration distribuée. Il est recommandé d'utiliser Accelerator.prepare() à la place.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model is defined
>>> model = accelerator.prepare_model(model)

prepare_optimizer

< >

( optimizer: torch.optim.Optimizerdevice_placement = None )

Paramètres

  • optimizer (torch.optim.Optimizer) — Un optimiseur PyTorch standard à préparer
  • device_placement (bool, facultatif) — Indique s'il faut placer l'optimiseur sur le bon appareil. La valeur par défaut est self.device_placement.

Prépare un Optimizer PyTorch pour l'entraînement dans toute configuration distribuée. Il est recommandé d'utiliser Accelerator.prepare() à la place.

Exemple :

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> optimizer = torch.optim.Adam(...)
>>> optimizer = accelerator.prepare_optimizer(optimizer, device_placement=True)

prepare_scheduler

< >

( scheduler: LRScheduler )

Paramètres

  • scheduler (torch.optim.lr_scheduler.LRScheduler) — Un ordonnanceur PyTorch standard pour préparer

Prépare un planificateur PyTorch pour l'entraînement dans toute configuration distribuée. Il est recommandé d'utiliser Accelerator.prepare() à la place.

Exemple :

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> optimizer = torch.optim.Adam(...)
>>> scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, ...)
>>> scheduler = accelerator.prepare_scheduler(scheduler)

print

< >

( *args**kwargs )

Remplacement direct de print() pour n'imprimer qu'une seule fois par serveur.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> accelerator.print("Hello world!")

profil

< >

( profile_handler: ProfileKwargs | None = None )

Paramètres

  • profile_handler (ProfileKwargs, facultatif) — Le gestionnaire de profil à utiliser pour ce gestionnaire de contexte. S'il n'est pas fourni, celui défini dans l'objet Accelerator sera utilisé.

Profilera le code à l’intérieur du gestionnaire de contexte. Le profil sera enregistré dans un fichier Chrome Trace si profile_handler.output_trace_dir est défini.

Un profile_handler différent peut être transmis pour remplacer celui défini dans l'objet Accelerator.

Exemple :

# Profile with default settings
from accelerate import Accelerator
from accelerate.utils import ProfileKwargs

accelerator = Accelerator()
with accelerator.profile() as prof:
    train()
accelerator.print(prof.key_averages().table())


# Profile with the custom handler
def custom_handler(prof):
    print(prof.key_averages().table(sort_by="self_cpu_time_total", row_limit=10))


kwargs = ProfileKwargs(schedule_option=dict(wait=1, warmup=1, active=1), on_trace_ready=custom_handler)
accelerator = Accelerator(kwarg_handler=[kwargs])
with accelerator.profile() as prof:
    for _ in range(10):
        train_iteration()
        prof.step()


# Profile and export to Chrome Trace
kwargs = ProfileKwargs(output_trace_dir="output_trace")
accelerator = Accelerator(kwarg_handler=[kwargs])
with accelerator.profile():
    train()

reduce

< >

( tensorreduction = 'sum'scale = 1.0 ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

Paramètres

  • tensor (torch.Tensor, ou un tuple/liste/dictionnaire imbriqué de torch.Tensor) — Les tenseurs à réduire sur tous les processus.
  • reduction (str, facultatif, par défaut “sum”) — Un type de réduction, peut être ‘sum’, ‘mean’, ‘max’ ou ‘none’. Si ‘none’, aucune opération n’est effectuée.
  • scale (float, facultatif, valeur par défaut 1.0) — Valeur de mise à l'échelle par défaut à appliquer après la réduction, uniquement valide sur XLA.

Retourne

torch.Tensor, ou un tuple/liste/dictionnaire imbriqué de torch.Tensor

Le ou les tenseurs réduits.

Réduire les valeurs de tensor sur tous les processus en fonction de reduction.

Note : Tous les processus reçoivent la valeur réduite.

Exemple :

>>> # Assuming two processes
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> process_tensor = torch.arange(accelerator.num_processes) + 1 + (2 * accelerator.process_index)
>>> process_tensor = process_tensor.to(accelerator.device)
>>> reduced_tensor = accelerator.reduce(process_tensor, reduction="sum")
>>> reduced_tensor
tensor([4, 6])

register_for_checkpointing

< >

( *objects )

Prend note des objects et les enregistre ou les charge lors de l'appel à save_state ou load_state.

Ils doivent être utilisés lorsque l'état est chargé ou enregistré dans le même script. Ils ne sont pas conçus pour être utilisés dans des scripts différents.

Chaque object doit disposer des fonctions load_state_dict et state_dict pour être stocké.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume `CustomObject` has a `state_dict` and `load_state_dict` function.
>>> obj = CustomObject()
>>> accelerator.register_for_checkpointing(obj)
>>> accelerator.save_state("checkpoint.pt")

register_load_state_pre_hook

< >

( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle

Paramètres

Retourne

torch.utils.hooks.RemovableHandle

un gestionnaire qui peut être utilisé pour supprimer le hook ajouté en appelant handle.remove()

Enregistre un pré-hook à exécuter avant l’appel de load_checkpoint dans Accelerator.load_state().

Le hook doit avoir la signature suivante :

hook(models: list[torch.nn.Module], input_dir: str) -> None

L'argument models correspond aux modèles tels qu'ils sont enregistrés dans l'état de l'accélérateur sous accelerator._models, et l'argument input_dir est l'argument input_dir transmis à Accelerator.load_state().

À n'utiliser qu'en conjonction avec Accelerator.register_save_state_pre_hook(). Peut s'avérer utile pour charger des configurations en plus des poids du modèle. Peut également être utilisé pour remplacer le chargement du modèle par une méthode personnalisée. Dans ce cas, veillez à retirer les modèles déjà chargés de la liste des modèles.

register_save_state_pre_hook

< >

( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle

Paramètres

Retourne

torch.utils.hooks.RemovableHandle

un gestionnaire qui peut être utilisé pour supprimer le hook ajouté en appelant handle.remove()

Enregistre un pré-hook à exécuter avant l'appel de save_checkpoint dans Accelerator.save_state().

Le hook doit avoir la signature suivante :

hook(models: list[torch.nn.Module], weights: list[dict[str, torch.Tensor]], input_dir: str) -> None

L'argument models correspond aux modèles tels qu'enregistrés dans l'état de l'accélérateur sous accelerator._models, l'argument weights correspond aux dictionnaires d'état des models, et l'argument input_dir est l'argument input_dir transmis à Accelerator.load_state().

À n'utiliser qu'en conjonction avec Accelerator.register_load_state_pre_hook(). Peut s'avérer utile pour enregistrer des configurations en plus des poids du modèle. Peut également être utilisé pour remplacer l'enregistrement du modèle par une méthode personnalisée. Dans ce cas, veillez à retirer les poids déjà chargés de la liste des poids.

save

< >

( objfsafe_serialization = False )

Paramètres

  • obj (object) — L'objet à enregistrer.
  • f (str ou os.PathLike) — Emplacement où enregistrer le contenu de obj.
  • safe_serialization (bool, facultatif, valeur par défaut False) — Indique s'il faut enregistrer obj en utilisant safetensors

Enregistrez l'objet passé sur le disque une fois par machine. Utilisez à la place de torch.save.

Note : Si save_on_each_node a été transmis dans un ProjectConfiguration, l'objet sera enregistré une fois par nœud, plutôt qu'une seule fois sur le nœud principal.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> arr = [0, 1, 2, 3]
>>> accelerator.save(arr, "array.pkl")

save_model

< >

( model: torch.nn.Modulesave_directory: Union[str, os.PathLike]max_shard_size: Union[int, str] = '10GB'safe_serialization: bool = True )

Paramètres

  • model — (torch.nn.Module) : Modèle à enregistrer. Le modèle peut être enveloppé ou non.
  • save_directory (str ou os.PathLike) — Répertoire de destination. Sera créé s'il n'existe pas.
  • max_shard_size (int ou str, facultatif, défaut : "10GB") — Taille maximale d'un checkpoint avant son fractionnement. Les shards du checkpoint auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme "5MB").

    Si un seul poids du modèle est plus grand que max_shard_size, il sera placé dans sa propre partition de point de contrôle, qui sera plus grande que max_shard_size.

  • safe_serialization (bool, facultatif, valeur par défaut True) — Indique si le modèle doit être enregistré à l'aide de safetensors ou de la méthode traditionnelle de PyTorch (qui utilise pickle).

Enregistrer un modèle afin qu'il puisse être rechargé à l'aide de load_checkpoint_in_model

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model = ...
>>> accelerator.save_model(model, save_directory)

save_state

< >

( output_dir: str | None = Nonesafe_serialization: bool = True**save_model_func_kwargs )

Paramètres

  • output_dir (str ou os.PathLike) — Le nom du dossier dans lequel enregistrer tous les poids et états pertinents.
  • safe_serialization (bool, facultatif, valeur par défaut True) — Indique si le modèle doit être enregistré à l'aide de safetensors ou de la méthode traditionnelle de PyTorch (qui utilise pickle).
  • save_model_func_kwargs (dict, facultatif) — Arguments supplémentaires par mot-clé pour l'enregistrement du modèle, qui peuvent être transmis à la fonction d'enregistrement sous-jacente, tels que les arguments facultatifs de la fonction save_checkpoint de DeepSpeed.

Enregistre les états actuels du modèle, de l’optimiseur, du scaler, des générateurs RNG et des objets enregistrés dans un dossier.

Si un ProjectConfiguration a été transmis à l'objet Accelerator avec automatic_checkpoint_naming activé, les points de contrôle seront enregistrés dans self.project_dir/checkpoints. Si le nombre d'enregistrements actuels est supérieur à total_limit, l'enregistrement le plus ancien est supprimé. Chaque point de contrôle est enregistré dans des dossiers distincts nommés checkpoint_<iteration>.

Sinon, elles sont simplement enregistrées dans output_dir.

À n'utiliser que lorsque l'on souhaite enregistrer un point de contrôle pendant l'entraînement et restaurer l'état dans le même environnement.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, lr_scheduler = ...
>>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
>>> accelerator.save_state(output_dir="my_checkpoint")

set_trigger

< >

( )

Définit le tenseur de déclenchement interne à 1 sur le processus actuel. Un contrôle ultérieur doit suivre en utilisant celui-ci, qui vérifiera sur tous les processus.

Note : N'exige pas wait_for_everyone()

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume later in the training script
>>> # `should_do_breakpoint` is a custom function to monitor when to break,
>>> # e.g. when the loss is NaN
>>> if should_do_breakpoint(loss):
...     accelerator.set_trigger()
>>> # Assume later in the training script
>>> if accelerator.check_breakpoint():
...     break

skip_first_batches

< >

( dataloadernum_batches: int = 0 )

Paramètres

  • dataloader (torch.utils.data.DataLoader) — Le chargeur de données dans lequel ignorer les lots.
  • num_batches (int, facultatif, valeur par défaut 0) — Le nombre de lots à ignorer

Crée un nouveau torch.utils.data.DataLoader qui ignorera efficacement les num_batches premiers lots.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
>>> skipped_dataloader = accelerator.skip_first_batches(dataloader, num_batches=2)
>>> # for the first epoch only
>>> for input, target in skipped_dataloader:
...     optimizer.zero_grad()
...     output = model(input)
...     loss = loss_func(output, target)
...     accelerator.backward(loss)
...     optimizer.step()

>>> # subsequent epochs
>>> for input, target in dataloader:
...     optimizer.zero_grad()
...     ...

split_between_processes

< >

( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )

Paramètres

  • inputs (list, tuple, torch.Tensor ou dict de list/tuple/torch.Tensor) — L'entrée à répartir entre les processus.
  • apply_padding (bool, optional, par défaut False) — Indique s'il faut appliquer un bourrage en répétant le dernier élément de l'entrée afin que tous les processus aient le même nombre d'éléments. Utile lors de l'exécution d'actions telles que Accelerator.gather() sur les sorties ou lors du passage de moins d'entrées que de processus. Si c'est le cas, n'oubliez pas de supprimer les éléments bourrés par la suite.

Divise input rapidement entre self.num_processes et peut ensuite être utilisé sur ce processus. Utile lors d’une inférence distribuée, par exemple avec des prompts différents.

Notez que lors de l'utilisation d'un dict, toutes les clés doivent avoir le même nombre d'éléments.

Exemple :

# Assume there are two processes
from accelerate import Accelerator

accelerator = Accelerator()
with accelerator.split_between_processes(["A", "B", "C"]) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]

with accelerator.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]

trigger_sync_in_backward

< >

( model )

Paramètres

  • model (torch.nn.Module) — Le modèle pour lequel déclencher la synchronisation des gradients.

Déclencher la synchronisation des gradients lors du prochain passage en arrière du modèle après plusieurs passages en avant sous Accelerator.no_sync (applicable uniquement dans les scénarios multi-GPU).

Si le script n'est pas lancé en mode distribué, ce gestionnaire de contexte ne fait rien.

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)

>>> with accelerator.no_sync():
...     loss_a = loss_func(model(input_a))  # first forward pass
...     loss_b = loss_func(model(input_b))  # second forward pass
>>> accelerator.backward(loss_a)  # No synchronization across processes, only accumulate gradients
>>> with accelerator.trigger_sync_in_backward(model):
...     accelerator.backward(loss_b)  # Synchronization across all processes
>>> optimizer.step()
>>> optimizer.zero_grad()

unscale_gradients

< >

( optimizer = None )

Paramètres

  • optimizer (torch.optim.Optimizer ou list[torch.optim.Optimizer], facultatif) — L’optimiseur (ou les optimiseurs) pour lesquels déséquilibrer les gradients. Si non défini, déséquilibre les gradients sur tous les optimiseurs passés à prepare().

Désamplifier les gradients lors de l’entraînement en précision mixte avec AMP. Cette opération est un noop dans tous les autres contextes.

Il est probablement appelé via Accelerator.clipgrad_norm() ou Accelerator.clipgrad_value()

Exemple :

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer = accelerator.prepare(model, optimizer)
>>> outputs = model(inputs)
>>> loss = loss_fn(outputs, labels)
>>> accelerator.backward(loss)
>>> accelerator.unscale_gradients(optimizer=optimizer)

unwrap_model

< >

( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = True ) → torch.nn.Module

Paramètres

  • model (torch.nn.Module) — Le modèle à déballer.
  • keep_fp32_wrapper (bool, facultatif, valeur par défaut True) — Indique s'il faut conserver le hook de précision mixte s'il a été ajouté.
  • keep_torch_compile (bool, facultatif, valeur par défaut True) — Indique s'il faut conserver le modèle compilé sans le décompiler.

Retourne

torch.nn.Module

Le modèle non enveloppé.

Développe le model en retirant la couche supplémentaire éventuellement ajoutée par prepare(). Utile avant d'enregistrer le modèle.

Exemple :

>>> # Assuming two GPU processes
>>> from torch.nn.parallel import DistributedDataParallel
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model = accelerator.prepare(MyModel())
>>> print(model.__class__.__name__)
DistributedDataParallel

>>> model = accelerator.unwrap_model(model)
>>> print(model.__class__.__name__)
MyModel

verify_device_map

< >

( model: torch.nn.Module )

Vérifie que model n'a pas été préparé pour l'inférence de grands modèles avec une carte d'appareils ressemblant à auto.

wait_for_everyone

< >

( )

Arrêtera l'exécution du processus en cours jusqu'à ce que tous les autres processus aient atteint ce point (donc cela ne fait rien lorsque le script est exécuté dans un seul processus). Utile à faire avant d'enregistrer un modèle.

Exemple :

>>> # Assuming two GPU processes
>>> import time
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> if accelerator.is_main_process:
...     time.sleep(2)
>>> else:
...     print("I'm waiting for the main process to finish its sleep...")
>>> accelerator.wait_for_everyone()
>>> # Should print on every process at the same time
>>> print("Everyone is here")

Utilitaires

accelerate.utils.gather_object

< >

( object: Any )

Paramètres

  • object (liste/tuple/dictionnaire imbriqué d'objets sérialisables) — Les données à collecter.

Récupérer récursivement un objet dans une liste/tuple/dictionnaire imbriqué d'objets à partir de tous les appareils.

Update on GitHub

←Entraînement sur des TPU Classes avec état→