Accelerate documentation

Utilitários de Paralelismo de Dados Totalmente Fragmentados

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

Utilitários de Paralelismo de Dados Totalmente Fragmentados

enable_fsdp_ram_efficient_loading

accelerate.utils.enable_fsdp_ram_efficient_loading

< >

( )

Permite o carregamento eficiente de memória RAM de modelos do Hugging Face para FSDP no ambiente.

disable_fsdp_ram_efficient_loading

accelerate.utils.disable_fsdp_ram_efficient_loading

< >

( )

Desativa o carregamento eficiente de RAM de modelos do Hugging Face para FSDP no ambiente.

merge_fsdp_weights

accelerate.utils.merge_fsdp_weights

< >

( checkpoint_dir: stroutput_path: strsafe_serialization: bool = Trueremove_checkpoint_dir: bool = False )

Parâmetros

  • checkpoint_dir (str) — O diretório que contém os checkpoints do FSDP (pode ser do modelo ou do otimizador).
  • output_path (str) — O caminho para salvar o checkpoint mesclado.
  • safe_serialization (bool, opcional, padrão True) — Se as mesclas de pesos devem ser salvas com safetensors (recomendado).
  • remove_checkpoint_dir (bool, opcional, padrão False) — Se a pasta de checkpoint deve ser removida após a fusão.

Merga os pesos de checkpoints de modelos FSDP em shards em um checkpoint único combinado. Deve ser usado se SHARDED_STATE_DICT foi usado para o modelo. Os pesos serão salvos em {output_path}/model.safetensors se safe_serialization, caso contrário em pytorch_model.bin.

Observação: este é um processo limitado pela CPU.

FullyShardedDataParallelPlugin

classe accelerate.FullyShardedDataParallelPlugin

< >

( fsdp_version: int = Nonesharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = Nonereshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = Nonebackward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = Nonemixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = Noneauto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = Nonecpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = Noneignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = Nonestate_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = Nonestate_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = Noneoptim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = Nonelimit_all_gathers: bool = Trueuse_orig_params: bool | None = Noneparam_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = Nonesync_module_states: bool | None = Noneforward_prefetch: bool = Noneactivation_checkpointing: bool = Noneactivation_checkpointing_offload: bool = Nonecpu_ram_efficient_loading: bool = Nonetransformer_cls_names_to_wrap: list[str] | None = Nonemin_num_params: int | None = None )

Parâmetros

  • fsdp_version (int, padrão 1) — A versão do FSDP a ser usada. O padrão é 1. Se definido como 2, o launcher espera que a configuração seja convertida para o formato FSDP2.
  • sharding_strategy (Union[str, torch.distributed.fsdp.ShardingStrategy], padrão 'FULL_SHARD') — Estratégia de sharding a ser utilizada. Deve ser uma str ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Está obsoleta em favor de reshard_after_forward.
  • reshard_after_forward (Union[str, torch.distributed.fsdp.ShardingStrategy, bool], padrão 'FULL_SHARD' para fsdp_version=1 e True para fsdp_version=2) — Estratégia de sharding a ser utilizada. Deve ser um bool se fsdp_version estiver definido como 2, caso contrário, um str ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy.
  • backward_prefetch (Union[str, torch.distributed.fsdp.BackwardPrefetch], padrão 'NO_PREFETCH') — Estratégia de pré-busca reversa a ser utilizada. Deve ser uma str ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch.
  • mixed_precision_policy (Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], padrão None) — Uma configuração para habilitar o treinamento com precisão mista usando FullyShardedDataParallel. Se um dict for passado, ele deve ter as seguintes chaves: param_dtype, reduce_dtype e buffer_dtype. Pode ser uma instância de torch.distributed.fsdp.MixedPrecisionPolicy se fsdp_version estiver definido como 2. Se um str for passado, ele deve ser um dos seguintes valores: fp8, fp16, bf16, fp32, e é usado para definir param_dtype, reduce_dtype e buffer_dtype.
  • auto_wrap_policy (Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults to NO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of transformer_based_wrap, size_based_wrap, or no_wrap. See torch.distributed.fsdp.wrap.size_based_wrap_policy` for a direction on what it should look like.
  • cpu_offload (Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy], padrão False) — Se os parâmetros devem ser transferidos para a CPU. Deve ser um bool ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload ou torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy se fsdp_version estiver definido como 2.
  • ignored_modules (Optional[Union[Iterable[torch.nn.Module], str]], padrão None) — Uma lista de módulos a serem ignorados ao envolver com FSDP. Ao passar uma string, os módulos serão correspondidos por nome usando regex fullmatch. Se fsdp_version estiver definido como 2, os módulos são convertidos em parâmetros e utilizados.
  • state_dict_type (Union[str, torch.distributed.fsdp.StateDictType], padrão 'FULL_STATE_DICT') — Tipo de state dict a ser usado. Se for uma string, deve ser um de full_state_dict, local_state_dict ou sharded_state_dict.
  • state_dict_config (Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], padrão None) — Configuração do state dict a ser utilizada. É determinada com base no state_dict_type caso não seja fornecida.
  • optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], padrão None) — Configuração do state dict do otimizador a ser usada. É determinada com base no state_dict_type caso não seja fornecida.
  • limit_all_gathers (bool, padrão True) — Se o FSDP deve sincronizar explicitamente a thread de CPU para evitar que haja muitos all-gathers em andamento. Este bool afeta apenas as estratégias shardadas que agendam all-gathers. Habilitar isso pode ajudar a reduzir o número de retries de malloc da CUDA.
  • use_orig_params (bool, padrão False) — Se deve usar os parâmetros originais para o otimizador.
  • param_init_fn (Optional[Callable[[torch.nn.Module], None], padrão None) — Um Callable[torch.nn.Module] -> None que especifica como os módulos que estão atualmente no dispositivo meta devem ser inicializados em um dispositivo real. Aplicável apenas quando sync_module_states é True. Por padrão, é um lambda que chama to_empty no módulo.
  • sync_module_states (bool, padrão False) — Se cada unidade FSDP individualmente envolvida deve transmitir os parâmetros do módulo a partir do rank 0 para garantir que eles sejam os mesmos em todos os ranks após a inicialização. O padrão é False, a menos que cpu_ram_efficient_loading seja True, caso em que será habilitado forçadamente.
  • forward_prefetch (bool, padrão False) — Se o FSDP deve pré-buscar explicitamente o próximo all-gather durante a execução da passagem de forward. Use apenas com grafos estáticos.
  • activation_checkpointing (bool, padrão False) — Uma técnica para reduzir o uso de memória limpando as ativações de determinadas camadas e recalculando-as durante uma passada de retropropagação. Efetivamente, isso troca tempo extra de computação por um uso reduzido de memória.
  • cpu_ram_efficient_loading (bool, padrão None) — Se True, apenas o primeiro processo carrega o checkpoint do modelo pré-treinado, enquanto todos os outros processos têm pesos vazios. Aplicável apenas para Transformers. Ao usar isso, sync_module_states precisa ser True.
  • transformer_cls_names_to_wrap (Optional[List[str]], padrão None) — Uma lista de nomes de classes de camadas de transformer para envolver. Aplicável apenas quando auto_wrap_policy é transformer_based_wrap.
  • min_num_params (Optional[int], padrão None) — O número mínimo de parâmetros que um módulo deve ter para ser envolvido. Aplicável apenas quando auto_wrap_policy é size_based_wrap.

Este plugin é usado para habilitar o paralelismo totalmente fragmentado de dados.

set_auto_wrap_policy

< >

( model )

Dado model, cria um auto_wrap_policy com base na política passada e se podemos usar o transformer_cls_to_wrap

set_mixed_precision

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

Define a política de precisão mista para FSDP

set_state_dict_type

< >

( state_dict_type = None )

Defina a configuração do state dict com base no StateDictType.

validate_mixed_precision_policy

< >

( )

Valida a política de precisão mista, abstraída para não importar os módulos se não forem necessários.

fsdp2_load_full_state_dict

accelerate.utils.fsdp2_load_full_state_dict

< >

( acceleratormodel: Modulefull_sd: dictcpu_offload: bool = False )

Parâmetros

  • accelerator (Accelerator) — A instância do acelerador
  • model (torch.nn.Module) — O modelo para o qual o state dict será carregado, esperado estar no meta device ou um pico de VRAM pode ocorrer
  • full_sd (dict) — O state dict completo a ser carregado, pode estar apenas no rank 0
  • cpu_offload (bool, padrão False) — Se True, move os parâmetros fragmentados para a CPU após a distribuição. Obrigatório quando o offloading de CPU do FSDP está habilitado.

Carrega o state dict completo (que pode estar apenas no rank 0) para o modelo shardado. Isso é feito transmitindo os parâmetros do rank 0 para todos os outros ranks. Esta função modifica o modelo in-place.

fsdp2_switch_optimizer_parameters

accelerate.utils.fsdp2_switch_optimizer_parameters

< >

( optimizer: Optimizermapping: dict )

Parâmetros

  • optimizer (torch.optim.Optimizer) — Instância do otimizador que contém os parâmetros originais do modelo
  • mapping (dict) — Mapeamento do parâmetro original (especificado por data_ptr) para o parâmetro fragmentado

Exceções

KeyError

  • KeyError — Se um parâmetro no otimizador não pôde ser trocado pela sua versão particionada. Isso nunca deveria acontecer e indica um bug. Se mantivéssemos os parâmetros originais em vez de lançar a exceção, o treinamento não seria numericamente correto e os pesos não seriam atualizados.

Alterna os parâmetros do otimizador para novos (parâmetros fragmentados no caso usual). Esta função modifica o otimizador in-place.

fsdp2_prepare_model

accelerate.utils.fsdp2_prepare_model

< >

( acceleratormodel: Module ) → torch.nn.Module

Parâmetros

  • accelerator (Accelerator) — A instância do acelerador
  • model (torch.nn.Module) — O modelo a ser preparado

Retorna

torch.nn.Module

Modelo preparado

Prepara o modelo para FSDP2 in-place. Também retorna o modelo para evitar o uso indevido do modelo original.

fsdp2_prepare_auto_wrap_policy

Update on GitHub