Accelerate documentation

Classes avec état

Accelerate

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Classes avec état

Ci-dessous figurent des variantes d'une classe singleton au sens où toutes les instances partagent le même état, initialisé lors de la première instanciation.

Ces classes sont immuables et stockent des informations sur certaines configurations ou états.

PartialState

classe accelerate.PartialState

( cpu: bool = False**kwargs )

Paramètres

cpu (bool, facultatif) — Indique s'il faut forcer l'exécution du script sur le CPU. Si défini sur True, ignore tous les accélérateurs disponibles et force l'exécution sur le CPU.
kwargs (arguments supplémentaires par mot-clé, facultatif) — Arguments supplémentaires par mot-clé à passer à la fonction init_process_group appropriée. Les kwargs valides peuvent être trouvés dans utils.InitProcessGroupKwargs. Consultez la section Exemples pour un usage détaillé.

Classe singleton qui contient des informations sur l'environnement d'entraînement actuel et des fonctions pour aider au contrôle des processus. Conçue pour être utilisée lorsque seul le contrôle des processus et les états d'exécution des appareils sont nécessaires. N'a pas besoin d'être initialisée à partir de Accelerator.

Attributs disponibles :

device (torch.device) — L'appareil à utiliser.
distributed_type (DistributedType) — Le type d’environnement distribué actuellement utilisé.
local_process_index (int) — L'index du processus actuel sur le serveur actuel.
mixed_precision (str) — Indique si le script actuel utilise la précision mixte et, le cas échéant, le type de précision mixte utilisé. (Choisir parmi ‘no’,‘fp16’,‘bf16 ou ‘fp8’).
num_processes (int) — Le nombre de processus actuellement lancés en parallèle.
process_index (int) — L'index du processus actuel.
is_last_process (bool) — Indique si le processus actuel est le dernier.
is_main_process (bool) — Indique si le processus actuel est le processus principal.
is_local_main_process (bool) — Indique si le processus actuel est le processus principal sur le nœud local.
debug (bool) — Indique si le script actuel est exécuté en mode de débogage.

Exemple :

from accelerate.utils import InitProcessGroupKwargs

# To include `InitProcessGroupKwargs`, init then call `.to_kwargs()`
kwargs = InitProcessGroupKwargs(...).to_kwargs()
state = PartialState(**kwargs)

destroy_process_group

( group = None )

Détruit le groupe de processus. Si aucun n'est spécifié, le groupe de processus par défaut est détruit.

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.state import PartialState

>>> state = PartialState()
>>> with state.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 {state.local_process_index}")

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

on_last_process

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

Paramètres

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

Décorateur qui exécute uniquement la fonction décorée sur le dernier processus.

Exemple :

# Assume we have 4 processes.
from accelerate.state import PartialState

state = PartialState()


@state.on_last_process
def print_something():
    print(f"Printed on process {state.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.

Décorateur qui exécute uniquement la fonction décorée sur le processus principal local.

Exemple :

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

state = PartialState()


@state.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.

Décorateur qui n'exécute la fonction décorée que sur le processus portant l'index donné sur le nœud actuel.

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.

Décorateur qui exécute la fonction décorée uniquement sur le processus principal.

Exemple :

>>> from accelerate.state import PartialState

>>> state = PartialState()


>>> @state.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.

Décorateur qui n'exécute la fonction décorée que sur le processus portant l'index donné.

Exemple :

# Assume we have 4 processes.
from accelerate.state import PartialState

state = PartialState()


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


print_something()
"Printed on process 2"

set_device

( )

Définit l'appareil dans self.device sur l'environnement distribué actuel.

split_between_processes

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

Paramètres

inputs (list, tuple, torch.Tensor, dict de list/tuple/torch.Tensor, ou datasets.Dataset) — 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 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 PartialState

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

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

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.state import PartialState

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

AcceleratorState

classe accelerate.state.AcceleratorState

( mixed_precision: str | None = Nonecpu: bool = Falsedynamo_plugin = Nonedeepspeed_plugin = Nonefsdp_plugin = Nonetorch_tp_plugin = Nonemegatron_lm_plugin = Noneparallelism_config = None_from_accelerator: bool = False**kwargs )

Classe singleton qui contient des informations sur l'environnement d'entraînement actuel.

Attributs disponibles :

device (torch.device) — L'appareil à utiliser.
distributed_type (DistributedType) — Le type d’environnement distribué actuellement utilisé.
parallelism_config (ParallelismConfig) — La configuration de parallélisme pour l'environnement d'entraînement actuel. Elle est utilisée pour configurer l'environnement d'entraînement distribué.
initialisé (bool) — Indique si l'objet AcceleratorState a été initialisé à partir de Accelerator.
local_process_index (int) — L'index du processus actuel sur le serveur actuel.
mixed_precision (str) — Indique si le script actuel utilise la précision mixte et, le cas échéant, le type de précision mixte utilisé. (Choisir parmi ‘no’,‘fp16’,‘bf16 ou ‘fp8’).
num_processes (int) — Le nombre de processus actuellement lancés en parallèle.
process_index (int) — L'index du processus actuel.
is_last_process (bool) — Indique si le processus actuel est le dernier.
is_main_process (bool) — Indique si le processus actuel est le processus principal.
is_local_main_process (bool) — Indique si le processus actuel est le processus principal sur le nœud local.
debug (bool) — Indique si le script actuel est exécuté en mode de débogage.

destroy_process_group

( group = None )

Détruit le groupe de processus. Si aucun n'est spécifié, le groupe de processus par défaut est détruit.

Si self.fork_launched est True et group est None, rien ne se passe.

get_deepspeed_plugin

( name: str )

Retourne le DeepSpeedPlugin avec la plugin_key donnée.

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.

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.

select_deepspeed_plugin

( name: str | None = None )

Active le DeepSpeedPlugin avec le name donné et désactive tous les autres plugins.

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, defaults to False) — Whether to apply padding by repeating the last element of the input so that all processes have the same number of elements. Useful when trying to perform actions such as gather() on the outputs or passing in less inputs than there are processes. If so, just remember to drop the padded elements afterwards.

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.state import AcceleratorState

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

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

GradientState

classe accelerate.state.GradientState

( gradient_accumulation_plugin: GradientAccumulationPlugin | None = None )

Classe singleton qui contient des informations relatives à la synchronisation des gradients pour l'accumulation de gradients

Attributs disponibles :

end_of_dataloader (bool) — Indique si la fin du dataloader actuel a été atteinte
remainder (int) — Le nombre d'échantillons supplémentaires ajoutés lors du bourrage du chargeur de données
sync_gradients (bool) — Indique si les gradients doivent être synchronisés sur tous les appareils
active_dataloader (Optional[DataLoader]) — Le dataloader actuellement itéré
dataloader_references (List[Optional[DataLoader]]) — Une liste de références vers les dataloaders sur lesquels l'itération est effectuée
num_steps (int) — Le nombre d'étapes à accumuler
adjust_scheduler (bool) — Indique si le planificateur doit être ajusté pour prendre en compte l'accumulation des gradients
sync_with_dataloader (bool) — Indique si les gradients doivent être synchronisés à la fin de l'itération du dataloader et si le nombre total d'étapes doit être réinitialisé
is_xla_gradients_synced (bool) — Indique si les gradients XLA ont été synchronisés. Il est initialisé à false. Une fois les gradients réduits avant l'étape de l'optimiseur, ce drapeau est passé à true. Par la suite, après chaque étape, le drapeau est réinitialisé à false. FSDP synchronise toujours les gradients, par conséquent is_xla_gradients_synced est toujours true.

Update on GitHub

←Accélérateur La ligne de commande→