Accelerate documentation
Classes com estado
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
< source >( cpu: bool = False**kwargs )
Parâmetros
- cpu (
bool, opcional) — Se deve forçar o script a ser executado na CPU. Se definido comoTrue, 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_grouprelevante. Oskwargsvá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)Destruir o grupo de processos. Se nenhum for especificado, o grupo de processos padrão será destruído.
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}")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
< source >( function: Callable[..., Any] )
Decorator que executa a função decorada apenas no último processo.
on_local_main_process
< source >( function: Callable[..., Any] | None = None )
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
< source >( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )
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
< source >( function: Callable[..., Any] | None = None )
Decorator que executa a função decorada apenas no processo principal.
on_process
< source >( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )
Decorator que executa a função decorada apenas no processo com o índice especificado.
Define o dispositivo em self.device para o ambiente distribuído atual.
split_between_processes
< source >( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )
Parâmetros
- inputs (
list,tuple,torch.Tensor,dictdelist/tuple/torch.Tensor, oudatasets.Dataset) — A entrada a ser dividida entre os processos. - apply_padding (
bool,optional, defaults toFalse) — 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 comogather()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"]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
< source >( 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 oAcceleratorStatefoi inicializado a partir doAccelerator. - 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.
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.
Retorna o DeepSpeedPlugin com a plugin_key especificada.
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.
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.
Ativa o DeepSpeedPlugin com o name fornecido e desativa todos os outros plugins.
split_between_processes
< source >( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )
Parâmetros
- inputs (
list,tuple,torch.Tensoroudictdelist/tuple/torch.Tensor) — A entrada a ser dividida entre os processos. - apply_padding (
bool,optional, defaults toFalse) — 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 comogather()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
< source >( 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.