Accelerate documentation

Classes com estado

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Classes com estado

Abaixo estão variações de uma classe singleton no sentido de que todas as instâncias compartilham o mesmo estado, que é inicializado na primeira instanciação.

Essas classes são imutáveis e armazenam informações sobre determinadas configurações ou estados.

PartialState

classe accelerate.PartialState

< >

( cpu: bool = False**kwargs )

Parâmetros

  • cpu (bool, opcional) — Se deve forçar o script a ser executado na CPU. Se definido como True, ignora qualquer acelerador disponível e força a execução na CPU.
  • kwargs (argumentos de palavra-chave adicionais, opcional) — Argumentos de palavra-chave adicionais para passar à função init_process_group relevante. Os kwargs válidos podem ser encontrados em utils.InitProcessGroupKwargs. Consulte a seção de exemplos para o uso detalhado.

Classe singleton que possui informações sobre o ambiente de treinamento atual e funções para auxiliar no controle de processos. Projetada para ser usada quando apenas o controle de processos e os estados de execução de dispositivos são necessários. Não precisa ser inicializada a partir de Accelerator.

Atributos disponíveis:

  • device (torch.device) — O dispositivo a ser utilizado.
  • distributed_type (DistributedType) — O tipo de ambiente distribuído atualmente em uso.
  • local_process_index (int) — O índice do processo atual no servidor atual.
  • mixed_precision (str) — Indica se o script atual usará precisão mista e, em caso afirmativo, o tipo de precisão mista a ser utilizado. (Escolha entre ‘no’,‘fp16’,‘bf16 ou ‘fp8’).
  • num_processes (int) — O número de processos atualmente lançados em paralelo.
  • process_index (int) — O índice do processo atual.
  • is_last_process (bool) — Indica se o processo atual é o último.
  • is_main_process (bool) — Indica se o processo atual é o principal.
  • is_local_main_process (bool) — Indica se o processo atual é o principal no nó local.
  • debug (bool) — Indica se o script atual está sendo executado em modo de depuração.

Exemplo:

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 )

Destruir o grupo de processos. Se nenhum for especificado, o grupo de processos padrão será destruído.

local_main_process_first

< >

( )

Permite que o processo principal local entre em um bloco with.

Os outros processos entrarão no bloco with após o processo principal sair.

Exemplo:

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

< >

( )

Permite que o processo principal execute primeiro dentro de um bloco with.

Os outros processos entrarão no bloco with após o processo principal sair.

Exemplo:

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

Parâmetros

  • function (Callable) — A função a ser decorada.

Decorator que executa a função decorada apenas no último processo.

Exemplo:

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

Parâmetros

  • function (Callable) — A função a ser decorada.

Decorator que executa a função decorada apenas no processo principal local.

Exemplo:

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

Parâmetros

  • function (Callable, opcional) — A função a ser decorada.
  • local_process_index (int, opcional) — O índice do processo local no qual executar a função.

Decorator que executa a função decorada apenas no processo com o índice especificado no nó atual.

Exemplo:

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

Parâmetros

  • function (Callable) — A função a ser decorada.

Decorator que executa a função decorada apenas no processo principal.

Exemplo:

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

Parâmetros

  • function (Callable, optional) — A função a ser decorada.
  • process_index (int, optional) — O índice do processo no qual a função será executada.

Decorator que executa a função decorada apenas no processo com o índice especificado.

Exemplo:

# 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

< >

( )

Define o dispositivo em self.device para o ambiente distribuído atual.

split_between_processes

< >

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

Parâmetros

  • inputs (list, tuple, torch.Tensor, dict de list/tuple/torch.Tensor, ou datasets.Dataset) — A entrada a ser dividida entre os processos.
  • apply_padding (bool, optional, defaults to False) — Se deve aplicar padding repetindo o último elemento da entrada para que todos os processos tenham o mesmo número de elementos. Útil ao tentar executar ações como gather() nas saídas ou ao passar menos entradas do que o número de processos. Se for o caso, lembre-se de descartar os elementos de padding em seguida.

Divide input entre self.num_processes rapidamente e pode ser usado em seguida nesse processo. Útil ao realizar inferência distribuída, como com diferentes prompts.

Observe que, ao usar um dict, todas as chaves precisam ter o mesmo número de elementos.

Exemplo:

# 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

< >

( )

Interromperá a execução do processo atual até que todos os outros processos tenham alcançado esse ponto (portanto, isso não faz nada quando o script é executado em apenas um processo). Útil para fazer antes de salvar um modelo.

Exemplo:

>>> # 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 que possui informações sobre o ambiente de treinamento atual.

Atributos disponíveis:

  • device (torch.device) — O dispositivo a ser utilizado.
  • distributed_type (DistributedType) — O tipo de ambiente distribuído atualmente em uso.
  • parallelism_config (ParallelismConfig) — A configuração de paralelismo para o ambiente de treinamento atual. Isso é usado para configurar o ambiente de treinamento distribuído.
  • inicializado (bool) — Indica se o AcceleratorState foi inicializado a partir do Accelerator.
  • local_process_index (int) — O índice do processo atual no servidor atual.
  • mixed_precision (str) — Indica se o script atual usará precisão mista e, em caso afirmativo, o tipo de precisão mista a ser utilizado. (Escolha entre ‘no’,‘fp16’,‘bf16 ou ‘fp8’).
  • num_processes (int) — O número de processos atualmente lançados em paralelo.
  • process_index (int) — O índice do processo atual.
  • is_last_process (bool) — Indica se o processo atual é o último.
  • is_main_process (bool) — Indica se o processo atual é o principal.
  • is_local_main_process (bool) — Indica se o processo atual é o principal no nó local.
  • debug (bool) — Indica se o script atual está sendo executado em modo de depuração.

destroy_process_group

< >

( group = None )

Destruir o grupo de processos. Se nenhum for especificado, o grupo de processos padrão será destruído.

If self.fork_launched is True and group is None, nothing happens.

get_deepspeed_plugin

< >

( name: str )

Retorna o DeepSpeedPlugin com a plugin_key especificada.

local_main_process_first

< >

( )

Permite que o processo principal local entre em um bloco with.

Os outros processos entrarão no bloco with após o processo principal sair.

main_process_first

< >

( )

Permite que o processo principal execute primeiro dentro de um bloco with.

Os outros processos entrarão no bloco with após o processo principal sair.

select_deepspeed_plugin

< >

( name: str | None = None )

Ativa o DeepSpeedPlugin com o name fornecido e desativa todos os outros plugins.

split_between_processes

< >

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

Parâmetros

  • inputs (list, tuple, torch.Tensor ou dict de list/tuple/torch.Tensor) — A entrada a ser dividida entre os processos.
  • apply_padding (bool, optional, defaults to False) — Se deve aplicar padding repetindo o último elemento da entrada para que todos os processos tenham o mesmo número de elementos. Útil ao tentar executar ações como gather() nas saídas ou ao passar menos entradas do que o número de processos. Se for o caso, lembre-se de descartar os elementos de padding em seguida.

Divide input entre self.num_processes rapidamente e pode ser usado em seguida nesse processo. Útil ao realizar inferência distribuída, como com diferentes prompts.

Observe que, ao usar um dict, todas as chaves precisam ter o mesmo número de elementos.

Exemplo:

# 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 que possui informações relacionadas à sincronização de gradientes para acúmulo de gradientes

Atributos disponíveis:

  • end_of_dataloader (bool) — Indica se atingimos o final do dataloader atual
  • remainder (int) — O número de amostras extras que foram adicionadas ao fazer o padding do dataloader
  • sync_gradients (bool) — Se os gradientes devem ser sincronizados entre todos os dispositivos
  • active_dataloader (Optional[DataLoader]) — O dataloader que está sendo iterado no momento
  • dataloader_references (List[Optional[DataLoader]]) — Uma lista de referências aos dataloaders que estão sendo iterados
  • num_steps (int) — O número de passos a serem acumulados
  • adjust_scheduler (bool) — Se o agendador deve ser ajustado para levar em conta a acumulação de gradientes
  • sync_with_dataloader (bool) — Se os gradientes devem ser sincronizados no final da iteração do dataloader e se o número total de passos deve ser reiniciado
  • is_xla_gradients_synced (bool) — Indica se os gradientes do XLA foram sincronizados. É inicializado como false. Uma vez que os gradientes tenham sido reduzidos antes do passo do otimizador, essa flag é definida como true. Subsequentemente, após cada passo, a flag é redefinida para false. O FSDP sempre sincroniza os gradientes, portanto is_xla_gradients_synced é sempre true.
Update on GitHub