Accelerate documentation
Acelerador
Acelerador
O Accelerator é a classe principal para habilitar o treinamento distribuído em qualquer tipo de configuração de treinamento. Leia o tutorial Adicione o Accelerator ao seu código para saber mais sobre como adicionar o Accelerator ao seu script.
Acelerador
classe accelerate.Accelerator
< source >( device_placement: bool = Truesplit_batches: bool = <object object at 0x7f7bf6a755a0>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 )
Parâmetros
- device_placement (
bool, opcional, padrãoTrue) — Se o acelerador deve ou não colocar objetos no dispositivo (tensores gerados pelo dataloader, modelo, etc…). - mixed_precision (
str, opcional) — Se deve ou não usar treinamento com precisão mista. Escolha entre ‘no’,‘fp16’,‘bf16’ ou ‘fp8’. O valor padrão será o da variável de ambienteACCELERATE_MIXED_PRECISION, que usará o valor padrão na configuração do accelerate do sistema atual ou a flag passada com o comandoaccelerate.launch. ‘fp8’ requer a instalação do transformers-engine. - gradient_accumulation_steps (
int, opcional, padrão 1) — O número de passos que devem passar antes que os gradientes sejam acumulados. Um número > 1 deve ser combinado comAccelerator.accumulate. Se não for passado, o valor padrão será o da variável de ambienteACCELERATE_GRADIENT_ACCUMULATION_STEPS. Também pode ser configurado por meio de umGradientAccumulationPlugin. - cpu (
bool, opcional) — Se deve forçar o script a ser executado na CPU. Se definido comoTrue, ignorará a GPU disponível e forçará a execução em apenas um processo. - dataloader_config (
DataLoaderConfiguration, opcional) — Uma configuração para como os dataloaders devem ser tratados em cenários distribuídos. - deepspeed_plugin (DeepSpeedPlugin ou dict de
str— DeepSpeedPlugin, opcional): Ajuste seus argumentos relacionados ao DeepSpeed usando este argumento. Este argumento é opcional e pode ser configurado diretamente usando accelerate config. Se estiver usando vários plugins, use a propriedadekeyconfigurada de cada plugin para acessá-los a partir deaccelerator.state.get_deepspeed_plugin(key). Alias paradeepspeed_plugins. - fsdp_plugin (FullyShardedDataParallelPlugin, opcional) — Ajuste os argumentos relacionados ao FSDP usando este argumento. Este argumento é opcional e pode ser configurado diretamente usando accelerate config
- torch_tp_plugin (
TorchTensorParallelPlugin, opcional) — Descontinuado: useparallelism_configcomtp_sizeem vez disso. - megatron_lm_plugin (MegatronLMPlugin, opcional) — Ajuste seus argumentos relacionados ao MegatronLM usando este argumento. Este argumento é opcional e pode ser configurado diretamente usando accelerate config
- rng_types (lista de
strou RNGType) — A lista de geradores de números aleatórios a serem sincronizados no início de cada iteração nos seus dataloaders preparados. Deve ser um ou vários dos seguintes:"torch": o gerador de números aleatórios base do torch"cuda": o gerador de números aleatórios CUDA (somente GPU)- O tipo de dispositivo de qualquer acelerador registrado do PyTorch: seu gerador de números aleatórios de dispositivo.
"xla": o gerador de números aleatórios do XLA (somente TPU)"generator": otorch.Generatordo sampler (ou do batch sampler, se não houver sampler no seu dataloader) ou do dataset iterável (se existir), caso o dataset subjacente seja desse tipo.
O padrão será
["torch"]para versões do PyTorch <=1.5.1 e["generator"]para versões do PyTorch >= 1.6. - log_with (lista de
str, LoggerType ou GeneralTracker, opcional) — Uma lista de loggers a serem configurados para o rastreamento de experimentos. Deve ser um ou vários dos seguintes:"all""tensorboard""wandb""trackio""aim""comet_ml""mlflow""dvclive""swanlab"Se"all"for selecionado, todos os trackers disponíveis no ambiente serão coletados e inicializados. Também pode aceitar implementações deGeneralTrackerpara trackers personalizados e pode ser combinado com"all".
- project_config (ProjectConfiguration, opcional) — Uma configuração para como o salvamento do estado pode ser tratado.
- project_dir (
str,os.PathLike, opcional) — Um caminho para um diretório para armazenar dados, como logs de loggers compatíveis localmente e, potencialmente, checkpoints salvos. - step_scheduler_with_optimizer (
bool, opcional, padrãoTrue) — Defina comoTruese o agendador de taxa de aprendizado for atualizado ao mesmo tempo que o otimizador, ouFalsese isso for feito apenas em certas circunstâncias (por exemplo, no final de cada época). - kwargs_handlers (lista de KwargsHandler, opcional) — Uma lista de KwargsHandler para personalizar como os objetos relacionados ao treinamento distribuído, ao profiling ou à precisão mista são criados. Veja kwargs para mais informações.
- dynamo_backend (
strou DynamoBackend, opcional, padrão"no") — Defina como um dos backends dynamo possíveis para otimizar seu treinamento com torch dynamo. - dynamo_plugin (TorchDynamoPlugin, opcional) —
Uma configuração para como o torch dynamo deve ser tratado, caso seja necessário mais ajuste do que apenas o
backendou omode. - gradient_accumulation_plugin (GradientAccumulationPlugin, opcional) —
Uma configuração para como a acumulação de gradientes deve ser tratada, caso seja necessário mais ajuste do que apenas o
gradient_accumulation_steps.
Cria uma instância de um acelerador para treinamento distribuído ou treinamento com precisão mista.
Atributos disponíveis:
- device (
torch.device) — O dispositivo a ser utilizado. - distributed_type (DistributedType) — A configuração de treinamento distribuído.
- local_process_index (
int) — O índice do processo na máquina atual. - mixed_precision (
str) — O modo de precisão mista configurado. - num_processes (
int) — O número total de processos usados para o treinamento. - optimizer_step_was_skipped (
bool) — Indica se a atualização do otimizador foi ignorada (devido a estouro de gradiente em precisão mista), caso em que a taxa de aprendizado não deve ser alterada. - process_index (
int) — O índice geral do processo atual entre todos os processos. - state (AcceleratorState) — O estado da configuração distribuída.
- sync_gradients (
bool) — Indica se os gradientes estão atualmente sendo sincronizados entre todos os processos. - use_distributed (
bool) — Indica se a configuração atual é para treinamento distribuído.
accumulate
< source >( *models )
Um gerenciador de contexto que envolve levemente e executa o acúmulo de gradientes automaticamente
Exemplo:
>>> 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()Aplicará a precisão mista automática dentro do bloco dentro deste gerenciador de contexto, se estiver habilitado. Caso contrário, nada diferente acontecerá.
É possível passar um autocast_handler diferente para substituir o definido no objeto Accelerator. Isso é
útil em blocos sob autocast onde você deseja reverter para fp32.
Escala os gradientes de acordo com o GradientAccumulationPlugin e chama o backward() correto com base na configuração.
Deve ser usado em vez de loss.backward().
Verifica se o tensor de gatilho interno foi definido como 1 em qualquer um dos processos. Se for o caso, retorna True e
reinicia o tensor de gatilho para 0.
Observação:
Não requer wait_for_everyone()
Exemplo:
>>> 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():
... breakAlias para Accelerate.free_memory, libera todas as referências aos objetos internos armazenados e chama o coletor de lixo. Você deve chamar este método entre dois treinos com modelos/otimizadores diferentes.
clip_grad_norm_
< source >( parametersmax_normnorm_type = 2 ) → torch.Tensor
Retorna
torch.Tensor
Norma total dos gradientes dos parâmetros (considerados como um único vetor).
Deve ser usado no lugar de torch.nn.utils.clip_grad_norm_.
Exemplo:
>>> 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()Deve ser usado no lugar de torch.nn.utils.clip_grad_value_.
Exemplo:
>>> 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()isso normalmente é chamado como parte de prepare, mas quando o dataloader foi preparado separadamente do modelo (para a chamada externa accelerator.prepare), essa chamada adicional precisa ser feita após prepare(model) (veja o HF Trainer como caso de uso)
Executa comportamentos especiais de encerramento do treinamento, como parar rastreadores apenas no processo principal ou destruir o grupo de processos. Deve ser chamado sempre no final do seu script ao usar rastreamento de experimentos.
Liberará todas as referências aos objetos internos armazenados e chamará o coletor de lixo. Você deve chamar este método entre dois treinos com modelos/otimizadores diferentes. Também redefinirá Accelerator.step para 0.
gather
< source >( tensor ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parâmetros
- tensor (
torch.Tensor, ou uma tupla/lista/dicionário aninhado detorch.Tensor) — Os tensores a serem reunidos em todos os processos.
Retorna
torch.Tensor, ou uma tupla/lista/dicionário aninhado de torch.Tensor
O(s) tensor(es) coletado(s). Observe que a primeira dimensão do resultado é num_processes multiplicado pela primeira dimensão dos tensores de entrada.
Reúna os valores em tensor entre todos os processos e concatene-os na primeira dimensão. Útil para reagrupar as previsões de todos os processos ao realizar a avaliação.
Nota: Esse gather ocorre em todos os processos.
Exemplo:
>>> # 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
< source >( input_datause_gather_object = False )
Parâmetros
- input_data (
torch.Tensor,object, uma tupla/lista/dicionário aninhado detorch.Tensor, ou uma tupla/lista/dicionário aninhado deobject) — Os tensores ou objetos para calcular métricas em todos os processos - use_gather_object(
bool) — Se deve forçar o uso de gather_object em vez de gather (o que já é feito se todos os objetos passados não contiverem tensores). Essa flag pode ser útil para reunir tensores de tamanhos diferentes que não queremos preencher e concatenar ao longo da primeira dimensão. O uso com tensores de GPU não é bem suportado e é ineficiente, pois implica transferência de GPU -> CPU, já que os tensores seriam serializados.
Reúne input_data e, potencialmente, remove duplicatas no último lote em um sistema distribuído. Deve ser
usado para reunir as entradas e os alvos para o cálculo de métricas.
Exemplo:
>>> # 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)
9get_state_dict
< source >( modelunwrap = True ) → dict
Parâmetros
- model (
torch.nn.Module) — Um modelo do PyTorch enviado por meio de Accelerator.prepare() - unwrap (
bool, opcional, padrãoTrue) — Se deve retornar o state_dict original subjacente demodelou o state_dict encapsulado
Retorna
dict
O dicionário de estado do modelo, potencialmente sem precisão total.
Retorna o dicionário de estado de um modelo enviado por Accelerator.prepare(), potencialmente sem precisão total.
get_tracker
< source >( name: strunwrap: bool = False ) → GeneralTracker
Retorna um tracker de self.trackers com base em name apenas no processo principal.
join_uneven_inputs
< source >( joinableseven_batches = None )
Parâmetros
- joinables (
list[torch.distributed.algorithms.Joinable]) — Uma lista de modelos ou otimizadores que são subclasses detorch.distributed.algorithms.Joinable. Mais comumente, um PyTorch Module que foi preparado comAccelerator.preparepara treinamento com DistributedDataParallel. - even_batches (
bool, opcional) — Se definido, isso substituirá o valor deeven_batchesdefinido noAccelerator. Se não for fornecido, o valor padrão doAcceleratorserá usado.
Um gerenciador de contexto que facilita o treinamento ou a avaliação distribuídos em entradas desiguais, que atua como um wrapper ao redor de torch.distributed.algorithms.join. Isso é útil quando o tamanho total do lote não divide uniformemente o comprimento do conjunto de dados.
join_uneven_inputsé suportado apenas para treinamento com Distributed Data Parallel em múltiplas GPUs. Para qualquer outra configuração, este método não terá efeito.
A sobrescrita de
even_batchesnão afetará carregadores de dados do estilo iterável.
Exemplo:
>>> 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
< source >( input_dir: str | None = Noneload_kwargs: dict | None = None**load_model_func_kwargs )
Parâmetros
- input_dir (
strouos.PathLike) — O nome da pasta em que todos os pesos e estados relevantes foram salvos. Pode serNoneseautomatic_checkpoint_namingfor usado, e recuperará a partir do checkpoint mais recente. - load_kwargs (
dict, opcional) — Argumentos de palavra-chave adicionais para a funçãoloadsubjacente, como argumentos opcionais para state_dict e optimizer. - load_model_func_kwargs (
dict, opcional) — Argumentos de palavra-chave adicionais para carregar o modelo que podem ser passados para a função de carregamento subjacente, como argumentos opcionais para a funçãoload_checkpointdo DeepSpeed ou ummap_locationpara carregar o modelo e o otimizador.
Carrega os estados atuais do modelo, otimizador, scaler, geradores de RNG e objetos registrados.
Deve ser usado apenas em conjunto com Accelerator.save_state(). Se um arquivo não estiver registrado para checkpointing, ele não será carregado se estiver armazenado no diretório.
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 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}")Executa a passagem reversa nos otimizadores LOMO.
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}")talvez_contexto_paralelo
< source >( buffers: list[torch.Tensor] | None = Nonebuffer_seq_dims: list[int] | None = Noneno_restore_buffers: set[torch.Tensor] | None = None )
Parâmetros
- buffers (
list[torch.Tensor],optional) — Buffers que serão fragmentados ao longo da dimensão da sequência. Exemplos comuns são buffers de entradas, rótulos ou embeddings posicionais. Este gerenciador de contexto modificará esses buffers in-place e, após sair do contexto, os buffers serão restaurados ao seu estado original. Para evitar restaurações desnecessárias, você pode usarno_restore_bufferspara especificar quais buffers não precisam ser restaurados. - buffer_seq_dims (
list[int],optional) — Dimensões de sequência dosbuffers. - no_restore_buffers (
set[torch.Tensor],optional) — Este conjunto deve ser um subconjunto debuffers. Especifica quais buffers do argumentobuffersnão serão restaurados após a saída do contexto. Esses buffers serão então mantidos em estado particionado.
Um gerenciador de contexto que permite o treinamento paralelo de contexto.
context_parallelé atualmente suportado com FSDP2 e requerparallelism_config.cp_size>
- Se nenhuma dessas condições for atendida, este gerenciador de contexto não terá efeito, embora, para permitir menos alterações no código, ele não lance uma Exception.
Este gerenciador de contexto precisa ser recriado a cada etapa de treinamento, conforme mostrado no exemplo abaixo.
no_sync
< source >( model )
Um gerenciador de contexto para desabilitar a sincronização de gradientes entre processos DDP, chamando torch.nn.parallel.DistributedDataParallel.no_sync.
Se model não estiver em DDP, este gerenciador de contexto não faz nada
Exemplo:
>>> 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
< source >( function: Callable[..., Any] )
Um decorador que executa a função decorada apenas no último processo. Também pode ser chamado usando a classe PartialState.
on_local_main_process
< source >( function: Callable[..., Any] | None = None )
Um decorador que executa a função decorada apenas no processo principal local. Também pode ser chamado usando a classe PartialState.
Exemplo:
# 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
< source >( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )
Um decorador que executa a função decorada apenas em um índice de processo local específico. Também pode ser chamado usando a classe PartialState.
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 )
Um decorador que executa a função decorada apenas no processo principal. Também pode ser chamado usando a classe PartialState.
on_process
< source >( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )
Um decorador que executa a função decorada apenas em um índice de processo específico. Também pode ser chamado usando a classe PartialState.
pad_across_processes
< source >( tensordim = 0pad_index = 0pad_first = False ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parâmetros
- tensor (lista/tupla/dicionário aninhado de
torch.Tensor) — Os dados a serem coletados. - dim (
int, opcional, padrão 0) — A dimensão na qual aplicar o preenchimento. - pad_index (
int, opcional, padrão 0) — O valor usado para o preenchimento. - pad_first (
bool, opcional, padrãoFalse) — Se o preenchimento deve ser feito no início ou no final.
Retorna
torch.Tensor, ou uma tupla/lista/dicionário aninhado de torch.Tensor
O(s) tensor(es) com preenchimento.
Preencha recursivamente os tensores em uma lista/tupla/dicionário aninhado de tensores de todos os dispositivos até o mesmo tamanho para que possam ser coletados com segurança.
Exemplo:
>>> # 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
< source >( *argsdevice_placement = None )
Parâmetros
- *args (lista de objetos) —
Qualquer um dos seguintes tipos de objetos:
torch.utils.data.DataLoader: Dataloader do PyTorchtorch.nn.Module: Módulo do PyTorchtorch.optim.Optimizer: Otimizador do PyTorchtorch.optim.lr_scheduler.LRScheduler: Agendador de taxa de aprendizado do PyTorch
- device_placement (
list[bool], opcional) — Usado para personalizar se a colocação automática de dispositivos deve ser realizada para cada objeto passado. Precisa ser uma lista do mesmo comprimento queargs. Não compatível com DeepSpeed ou FSDP.
Prepare todos os objetos passados em args para treinamento distribuído e precisão mista, em seguida, retorne-os na mesma ordem.
Você não precisa preparar um modelo se for usá-lo apenas para inferência, sem nenhum tipo de precisão mista
Exemplos:
>>> 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
< source >( data_loader: torch.utils.data.DataLoaderdevice_placement = Noneslice_fn_for_dispatch = None )
Parâmetros
- data_loader (
torch.utils.data.DataLoader) — Um DataLoader do PyTorch puro para preparar - device_placement (
bool, opcional) — Indica se os lotes devem ser colocados no dispositivo adequado no dataloader preparado. O valor padrão éself.device_placement. - 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.
Prepara um PyTorch DataLoader para treinamento em qualquer configuração distribuída. É recomendado usar Accelerator.prepare() em vez disso.
prepare_model
< source >( model: torch.nn.Moduledevice_placement: bool | None = Noneevaluation_mode: bool = False )
Parâmetros
- model (
torch.nn.Module) — Um modelo do PyTorch a ser preparado. Você não precisa preparar um modelo se ele for usado apenas para inferência, sem nenhum tipo de precisão mista - device_placement (
bool, opcional) — Se o modelo deve ou não ser colocado no dispositivo adequado. O valor padrão éself.device_placement. - evaluation_mode (
bool, opcional, padrãoFalse) — Se o modelo deve ser configurado apenas para avaliação, aplicando somente precisão mista etorch.compile(se configurado no objetoAccelerator).
Prepara um modelo do PyTorch para treinamento em qualquer configuração distribuída. É recomendado usar Accelerator.prepare() em vez disso.
prepare_optimizer
< source >( optimizer: torch.optim.Optimizerdevice_placement = None )
Prepara um otimizador do PyTorch para treinamento em qualquer configuração distribuída. É recomendado usar Accelerator.prepare() em vez disso.
prepare_scheduler
< source >( scheduler: LRScheduler )
Prepara um agendador do PyTorch para treinamento em qualquer configuração distribuída. É recomendado usar Accelerator.prepare() em vez disso.
Substituição direta de print() para imprimir apenas uma vez por servidor.
perfil
< source >( profile_handler: ProfileKwargs | None = None )
Fará o perfil do código dentro do gerenciador de contexto. O perfil será salvo em um arquivo Chrome Trace se profile_handler.output_trace_dir estiver definido.
Um profile_handler diferente pode ser passado para substituir o definido no objeto Accelerator.
Exemplo:
# 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
< source >( tensorreduction = 'sum'scale = 1.0 ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parâmetros
- tensor (
torch.Tensor, ou uma tupla/lista/dicionário aninhado detorch.Tensor) — Os tensores a serem reduzidos entre todos os processos. - reduction (
str, opcional, padrão “sum”) — Um tipo de redução, pode ser um de ‘sum’, ‘mean’, ‘max’ ou ‘none’. Se ‘none’, nenhuma operação será executada. - scale (
float, opcional, padrão 1.0) — Um valor de escala padrão a ser aplicado após o reduce, válido apenas no XLA.
Retorna
torch.Tensor, ou uma tupla/lista/dicionário aninhado de torch.Tensor
O(s) tensor(es) reduzido(s).
Reduza os valores em tensor entre todos os processos com base em reduction.
Nota: Todos os processos recebem o valor reduzido.
Exemplo:
>>> # 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])Faz anotação dos objects e os salva ou carrega durante o save_state ou load_state.
Esses devem ser utilizados quando o estado está sendo carregado ou salvo no mesmo script. Não foram projetados para serem usados em scripts diferentes.
Todo
objectdeve ter uma funçãoload_state_dicte uma funçãostate_dictpara ser armazenado.
register_load_state_pre_hook
< source >( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle
Parâmetros
- hook (
Callable) — Uma função a ser chamada em Accelerator.load_state() antes deload_checkpoint.
Retorna
torch.utils.hooks.RemovableHandle
um identificador que pode ser usado para remover o hook adicionado chamando
handle.remove()
Registra um pré-gancho para ser executado antes de load_checkpoint ser chamado em Accelerator.load_state().
O hook deve ter a seguinte assinatura:
hook(models: list[torch.nn.Module], input_dir: str) -> None
O argumento models são os modelos conforme salvos no estado do acelerador sob accelerator._models, e o argumento input_dir é o argumento input_dir passado para Accelerator.load_state().
Deve ser usado apenas em conjunto com Accelerator.register_save_state_pre_hook(). Pode ser útil para carregar configurações além dos pesos do modelo. Também pode ser usado para sobrescrever o carregamento do modelo com um método personalizado. Nesse caso, certifique-se de remover os modelos já carregados da lista de modelos.
register_save_state_pre_hook
< source >( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle
Parâmetros
- hook (
Callable) — Uma função a ser chamada em Accelerator.save_state() antes desave_checkpoint.
Retorna
torch.utils.hooks.RemovableHandle
um identificador que pode ser usado para remover o hook adicionado chamando
handle.remove()
Registra um pré-gancho para ser executado antes de save_checkpoint ser chamado em Accelerator.save_state().
O hook deve ter a seguinte assinatura:
hook(models: list[torch.nn.Module], weights: list[dict[str, torch.Tensor]], input_dir: str) -> None
O argumento models são os modelos salvos no estado do acelerador sob accelerator._models, o argumento weights são os state dicts dos models e o argumento input_dir é o argumento input_dir passado para Accelerator.load_state().
Deve ser usado apenas em conjunto com Accelerator.register_load_state_pre_hook(). Pode ser útil para salvar configurações além dos pesos do modelo. Também pode ser usado para sobrescrever o salvamento do modelo com um método personalizado. Nesse caso, certifique-se de remover os pesos já carregados da lista de pesos.
salvar
< source >( objfsafe_serialization = False )
Salve o objeto passado no disco uma vez por máquina. Use no lugar de torch.save.
Nota:
Se save_on_each_node foi passado como um ProjectConfiguration, o objeto será salvo uma vez por nó,
em vez de apenas uma vez no nó principal.
save_model
< source >( model: torch.nn.Modulesave_directory: Union[str, os.PathLike]max_shard_size: Union[int, str] = '10GB'safe_serialization: bool = True )
Parâmetros
- model — (
torch.nn.Module): Modelo a ser salvo. O modelo pode estar envolto ou não. - save_directory (
strouos.PathLike) — Diretório para o qual salvar. Será criado se não existir. - max_shard_size (
intoustr, opcional, padrão é"10GB") — O tamanho máximo de um checkpoint antes de ser dividido em shards. Os shards do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como uma string, deve ser composto por dígitos seguidos de uma unidade (como"5MB").Se um único peso do modelo for maior que
max_shard_size, ele ficará em seu próprio shard de checkpoint, que será maior quemax_shard_size. - safe_serialization (
bool, opcional, padrãoTrue) — Se o modelo deve ser salvo usandosafetensorsou da maneira tradicional do PyTorch (que usapickle).
Salve um modelo para que ele possa ser recarregado usando load_checkpoint_in_model
save_state
< source >( output_dir: str | None = Nonesafe_serialization: bool = True**save_model_func_kwargs )
Parâmetros
- output_dir (
strouos.PathLike) — O nome da pasta para salvar todos os pesos e estados relevantes. - safe_serialization (
bool, opcional, padrãoTrue) — Se o modelo deve ser salvo usandosafetensorsou da maneira tradicional do PyTorch (que usapickle). - save_model_func_kwargs (
dict, opcional) — Argumentos de palavra-chave adicionais para salvar o modelo que podem ser passados para a função de salvamento subjacente, como argumentos opcionais para a funçãosave_checkpointdo DeepSpeed.
Salva os estados atuais do modelo, otimizador, scaler, geradores de RNG e objetos registrados em uma pasta.
Se um ProjectConfiguration foi passado para o objeto Accelerator com automatic_checkpoint_naming habilitado,
os checkpoints serão salvos em self.project_dir/checkpoints. Se o número de salvamentos atuais for maior
que total_limit, o salvamento mais antigo será excluído. Cada checkpoint é salvo em pastas separadas nomeadas checkpoint_<iteration>.
Caso contrário, eles são apenas salvos em output_dir.
Deve ser usado apenas quando se deseja salvar um checkpoint durante o treinamento e restaurar o estado no mesmo ambiente.
Define o tensor de gatilho interno como 1 no processo atual. Uma verificação posterior deve ser feita usando este, que verificará em todos os processos.
Observação:
Não requer wait_for_everyone()
Exemplo:
>>> 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():
... breakskip_first_batches
< source >( dataloadernum_batches: int = 0 )
Cria um novo torch.utils.data.DataLoader que ignorará eficientemente as primeiras num_batches.
Exemplo:
>>> 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
< 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, padrãoFalse) — 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 comoAccelerator.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 depois.
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 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
< source >( model )
Dispare a sincronização dos gradientes na próxima passagem de retropropagação do modelo após várias passagens de propagação direta sob Accelerator.no_sync (aplicável apenas em cenários multi-GPU).
Se o script não for iniciado em modo distribuído, este gerenciador de contexto não faz nada.
Exemplo:
>>> 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
< source >( optimizer = None )
Parâmetros
- optimizer (
torch.optim.Optimizeroulist[torch.optim.Optimizer], opcional) — O(s) otimizador(es) para os quais as gradientes devem ser desescaladas. Se não definido, as gradientes serão desescaladas em todos os otimizadores que foram passados para prepare().
Desescala os gradientes no treinamento de precisão mista com AMP. Isso é um noop em todos os outros cenários.
Provavelmente deve ser chamado por meio de Accelerator.clipgrad_norm() ou Accelerator.clipgrad_value()
unwrap_model
< source >( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = True ) → torch.nn.Module
Parâmetros
- model (
torch.nn.Module) — O modelo a ser desembrulhado. - keep_fp32_wrapper (
bool, opcional, padrãoTrue) — Se o hook de precisão mista adicionado deve ser mantido. - keep_torch_compile (
bool, opcional, padrãoTrue) — Se deve ou não desembrulhar o modelo compilado, caso ele esteja compilado.
Retorna
torch.nn.Module
O modelo sem embrulho.
Desfaz a camada adicional que pode ter sido adicionada ao model pelo prepare(). Útil antes de salvar o modelo.
Exemplo:
>>> # 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__)
MyModelVerifica que model não foi preparado para inferência de modelos grandes com um device-map semelhante a auto.
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 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")Utilitários
accelerate.utils.gather_object
< source >( object: Any )
Recolher recursivamente um objeto em uma lista/tupela/dicionário aninhado de objetos de todos os dispositivos.