Accelerate documentation
Utilitários de Paralelismo de Dados Totalmente Fragmentados
Utilitários de Paralelismo de Dados Totalmente Fragmentados
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
Desativa o carregamento eficiente de RAM de modelos do Hugging Face para FSDP no ambiente.
merge_fsdp_weights
accelerate.utils.merge_fsdp_weights
< source >( 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ãoTrue) — Se as mesclas de pesos devem ser salvas com safetensors (recomendado). - remove_checkpoint_dir (
bool, opcional, padrãoFalse) — 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
< source >( 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ão1) — 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 umastrou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Está obsoleta em favor dereshard_after_forward. - reshard_after_forward (
Union[str, torch.distributed.fsdp.ShardingStrategy, bool], padrão'FULL_SHARD'parafsdp_version=1eTrueparafsdp_version=2) — Estratégia de sharding a ser utilizada. Deve ser um bool sefsdp_versionestiver definido como 2, caso contrário, umstrou uma instância detorch.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 umastrou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch. - mixed_precision_policy (
Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], padrãoNone) — Uma configuração para habilitar o treinamento com precisão mista usando FullyShardedDataParallel. Se umdictfor passado, ele deve ter as seguintes chaves:param_dtype,reduce_dtypeebuffer_dtype. Pode ser uma instância detorch.distributed.fsdp.MixedPrecisionPolicysefsdp_versionestiver definido como 2. Se umstrfor passado, ele deve ser um dos seguintes valores: fp8, fp16, bf16, fp32, e é usado para definirparam_dtype,reduce_dtypeebuffer_dtype. - auto_wrap_policy (
Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults toNO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one oftransformer_based_wrap,size_based_wrap, orno_wrap. Seetorch.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ãoFalse) — Se os parâmetros devem ser transferidos para a CPU. Deve ser umboolou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadoutorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicysefsdp_versionestiver definido como 2. - ignored_modules (
Optional[Union[Iterable[torch.nn.Module], str]], padrãoNone) — 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. Sefsdp_versionestiver 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 defull_state_dict,local_state_dictousharded_state_dict. - state_dict_config (
Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], padrãoNone) — Configuração do state dict a ser utilizada. É determinada com base nostate_dict_typecaso não seja fornecida. - optim_state_dict_config (
Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], padrãoNone) — Configuração do state dict do otimizador a ser usada. É determinada com base nostate_dict_typecaso não seja fornecida. - limit_all_gathers (
bool, padrãoTrue) — 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ãoFalse) — Se deve usar os parâmetros originais para o otimizador. - param_init_fn (
Optional[Callable[[torch.nn.Module], None], padrãoNone) — UmCallable[torch.nn.Module] -> Noneque especifica como os módulos que estão atualmente no dispositivo meta devem ser inicializados em um dispositivo real. Aplicável apenas quandosync_module_stateséTrue. Por padrão, é umlambdaque chamato_emptyno módulo. - sync_module_states (
bool, padrãoFalse) — 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 quecpu_ram_efficient_loadingsejaTrue, caso em que será habilitado forçadamente. - forward_prefetch (
bool, padrãoFalse) — 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ãoFalse) — 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ãoNone) — 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_statesprecisa serTrue. - transformer_cls_names_to_wrap (
Optional[List[str]], padrãoNone) — Uma lista de nomes de classes de camadas de transformer para envolver. Aplicável apenas quandoauto_wrap_policyétransformer_based_wrap. - min_num_params (
Optional[int], padrãoNone) — O número mínimo de parâmetros que um módulo deve ter para ser envolvido. Aplicável apenas quandoauto_wrap_policyésize_based_wrap.
Este plugin é usado para habilitar o paralelismo totalmente fragmentado de dados.
Dado model, cria um auto_wrap_policy com base na política passada e se podemos usar o transformer_cls_to_wrap
Define a política de precisão mista para FSDP
Defina a configuração do state dict com base no StateDictType.
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
< source >( 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ãoFalse) — 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
< source >( 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 pordata_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
< source >( acceleratormodel: Module ) → torch.nn.Module
Prepara o modelo para FSDP2 in-place. Também retorna o modelo para evitar o uso indevido do modelo original.