Accelerate documentation

Paralelismo de Dados Totalmente Fragmentado

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Paralelismo de Dados Totalmente Fragmentado

Para acelerar o treinamento de modelos enormes em tamanhos de lote maiores, podemos usar um modelo de paralelismo de dados totalmente fragmentado. Esse tipo de paradigma de paralelismo de dados permite ajustar mais dados e modelos maiores ao fragmentar os estados do otimizador, os gradientes e os parâmetros. Para ler mais sobre isso e seus benefícios, confira o blog sobre Fully Sharded Data Parallel. Integramos o recurso de treinamento Fully Sharded Data Parallel (FSDP) mais recente do PyTorch. Tudo o que você precisa fazer é ativá-lo por meio da configuração.

Como funciona por padrão

Na sua máquina(s), basta executar:

accelerate config

e responder às perguntas feitas. Isso gerará um arquivo de configuração que será usado automaticamente para definir corretamente as opções padrão ao executar

accelerate launch my_script.py --args_to_my_script

Por exemplo, é assim que você executaria examples/nlp_example.py (a partir da raiz do repositório) com o FSDP habilitado:

compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch_policy: BACKWARD_PRE
  fsdp_forward_prefetch: false
  fsdp_cpu_ram_efficient_loading: true
  fsdp_offload_params: false
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: SHARDED_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_transformer_layer_cls_to_wrap: BertLayer
  fsdp_use_orig_params: true
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false
accelerate launch examples/nlp_example.py

Atualmente, o Accelerate suporta as seguintes configurações por meio da CLI:

fsdp_sharding_strategy: [1] FULL_SHARD (divide em shards os estados do otimizador, os gradientes e os parâmetros), [2] SHARD_GRAD_OP (divide em shards os estados do otimizador e os gradientes), [3] NO_SHARD (DDP), [4] HYBRID_SHARD (divide em shards os estados do otimizador, os gradientes e os parâmetros dentro de cada nó, enquanto cada nó possui uma cópia completa), [5] HYBRID_SHARD_ZERO2 (divide em shards os estados do otimizador e os gradientes dentro de cada nó, enquanto cada nó possui uma cópia completa). Para mais informações, consulte a documentação oficial do PyTorch.

fsdp_offload_params : Decide se os parâmetros e gradientes devem ser transferidos para a CPU

fsdp_auto_wrap_policy: [1] TRANSFORMER_BASED_WRAP, [2] SIZE_BASED_WRAP, [3] NO_WRAP

fsdp_transformer_layer_cls_to_wrap: Aplicável apenas para Transformers. Ao usar fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP, o usuário pode fornecer uma string separada por vírgulas com os nomes das classes de camadas de transformer (sensível a maiúsculas e minúsculas) a serem envolvidas, por exemplo, BertLayer, GPTJBlock, T5Block, BertLayer,BertEmbeddings,BertSelfOutput. Isso é importante porque submódulos que compartilham pesos (por exemplo, camadas de embedding) não devem acabar em unidades FSDP envolvidas diferentes. Com essa política, a envoltura ocorre para cada bloco contendo Multi-Head Attention seguido de algumas camadas MLP. As camadas restantes, incluindo os embeddings compartilhados, são convenientemente envolvidas na mesma unidade FSDP mais externa. Portanto, use isso para modelos baseados em transformer. Você pode usar o model._no_split_modules para modelos Transformer respondendo yes para Do you want to use the model's_no_split_modulesto wrap. It will try to usemodel._no_split_modules` quando possível.

fsdp_min_num_params: número mínimo de parâmetros ao usar fsdp_auto_wrap_policy=SIZE_BASED_WRAP.

fsdp_backward_prefetch_policy: [1] BACKWARD_PRE, [2] BACKWARD_POST, [3] NO_PREFETCH

fsdp_forward_prefetch: se True, o FSDP faz explicitamente o pré-carregamento (prefetch) do próximo all-gather durante a execução da passagem de frente (forward pass). Deve ser usado apenas para modelos de grafo estático, pois o pré-carregamento segue a ordem de execução da primeira iteração. Ou seja, se a ordem dos submódulos mudar dinamicamente durante a execução do modelo, não ative esse recurso.

fsdp_state_dict_type: [1] FULL_STATE_DICT, [2] LOCAL_STATE_DICT, [3] SHARDED_STATE_DICT

fsdp_use_orig_params: Se True, permite requires_grad não uniforme durante a inicialização, o que significa suporte para parâmetros congelados e treináveis intercalados. Essa configuração é útil em casos como o ajuste fino eficiente em parâmetros, conforme discutido em este post. Essa opção também permite ter múltiplos grupos de parâmetros do otimizador. Isso deve ser True ao criar um otimizador antes de preparar/envolver o modelo com FSDP.

fsdp_cpu_ram_efficient_loading: Aplicável apenas a modelos do Transformers. Se True, apenas o primeiro processo carrega o checkpoint do modelo pré-treinado, enquanto todos os outros processos possuem pesos vazios. Isso deve ser definido como False se você encontrar erros ao carregar o modelo Transformers pré-treinado por meio do método from_pretrained. Quando esta configuração é True, fsdp_sync_module_states também deve ser True; caso contrário, todos os processos, exceto o principal, terão pesos aleatórios, levando a um comportamento inesperado durante o treinamento. Para que isso funcione, certifique-se de que o grupo de processos distribuídos seja inicializado antes de chamar o método from_pretrained do Transformers. Ao usar a API do Trainer, o grupo de processos distribuídos é inicializado quando você cria uma instância da classe TrainingArguments.

fsdp_sync_module_states: Se True, cada unidade FSDP individualmente envolvida transmitirá os parâmetros do módulo a partir do rank 0.

Para um controle adicional e mais refinado, você pode especificar outros parâmetros do FSDP por meio de FullyShardedDataParallelPlugin. Ao criar o objeto FullyShardedDataParallelPlugin, passe os parâmetros que não faziam parte da configuração do accelerate ou que você deseja sobrescrever. Os parâmetros do FSDP serão selecionados com base no arquivo de configuração do accelerate ou nos argumentos do comando de inicialização, e os outros parâmetros que você passar diretamente pelo objeto FullyShardedDataParallelPlugin definirão/sobrescreverão esses valores.

Abaixo está um exemplo:

from accelerate import FullyShardedDataParallelPlugin
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig

fsdp_plugin = FullyShardedDataParallelPlugin(
    state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),
    optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=False, rank0_only=False),
)

accelerator = Accelerator(fsdp_plugin=fsdp_plugin)

Salvando e carregando

A nova maneira recomendada de fazer checkpointing ao usar modelos FSDP é usar SHARDED_STATE_DICT como StateDictType ao configurar o accelerate config. Abaixo está o trecho de código para salvar usando a utilidade save_state do accelerate.

accelerator.save_state("ckpt")

Inspecione a pasta de checkpoint para ver o modelo e o otimizador como shards por processo:

ls ckpt
# optimizer_0  pytorch_model_0  random_states_0.pkl  random_states_1.pkl  scheduler.bin

cd ckpt

ls optimizer_0
# __0_0.distcp  __1_0.distcp

ls pytorch_model_0
# __0_0.distcp  __1_0.distcp

Para carregá-los novamente para retomar o treinamento, use o utilitário load_state do accelerate

accelerator.load_state("ckpt")

Ao usar save_pretrained do transformers, passe state_dict=accelerator.get_state_dict(model) para salvar o state dict do modelo. Abaixo está um exemplo:

  unwrapped_model.save_pretrained(
      args.output_dir,
      is_main_process=accelerator.is_main_process,
      save_function=accelerator.save,
+     state_dict=accelerator.get_state_dict(model),
)

State Dict

accelerator.get_state_dict chamará a implementação subjacente de model.state_dict usando o gerenciador de contexto FullStateDictConfig(offload_to_cpu=True, rank0_only=True) para obter o state dict apenas para o rank 0, e ele será descarregado para a CPU.

Em seguida, você pode passar state para o método save_pretrained. Existem vários modos para StateDictType e FullStateDictConfig que você pode usar para controlar o comportamento de state_dict. Para mais informações, consulte a documentação do PyTorch.

Se você optar por usar StateDictType.SHARDED_STATE_DICT, os pesos do modelo durante Accelerator.save_state serão divididos em n arquivos para cada sub-divisão no modelo. Para mesclá-los novamente em um único dicionário para carregar de volta no modelo mais tarde, após o treinamento, você pode usar a utilidade merge_weights:

from accelerate.utils import merge_fsdp_weights

# Our weights are saved usually in a `pytorch_model_fsdp_{model_number}` folder
merge_fsdp_weights("pytorch_model_fsdp_0", "output_path", safe_serialization=True)

A saída final será então salva em model.safetensors ou pytorch_model.bin (se safe_serialization=False for passado).

Isso também pode ser chamado usando a CLI:

accelerate merge-weights pytorch_model_fsdp_0/ output_path

Mapeamento entre as estratégias de sharding do FSDP e os estágios ZeRO do DeepSpeed

  • FULL_SHARD corresponde ao ZeRO Stage-3 do DeepSpeed. Faz o particionamento (sharding) dos estados do otimizador, dos gradientes e dos parâmetros.
  • SHARD_GRAD_OP corresponde ao ZeRO Stage-2 do DeepSpeed. Faz o particionamento dos estados do otimizador e dos gradientes.
  • NO_SHARD corresponde a ZeRO Stage-0. Não há particionamento, cada GPU possui uma cópia completa do modelo, dos estados do otimizador e dos gradientes.
  • HYBRID_SHARD corresponde a ZeRO++ Stage-3, no qual zero_hpz_partition_size=<num_gpus_per_node>. Aqui, isso fará o particionamento dos estados do otimizador, dos gradientes e dos parâmetros dentro de cada nó, enquanto cada nó possui uma cópia completa.

Algumas ressalvas a serem consideradas

  • Em caso de múltiplos modelos, passe os otimizadores para a chamada de prepare na mesma ordem dos modelos correspondentes, caso contrário accelerator.save_state() e accelerator.load_state() resultarão em comportamento incorreto/imprevisto.
  • Este recurso é incompatível com --predict_with_generate no script run_translation.py da biblioteca Transformers.

Para mais controle, os usuários podem aproveitar o FullyShardedDataParallelPlugin. Após criar uma instância desta classe, os usuários podem passá-la para a instanciação da classe Accelerator. Para mais informações sobre essas opções, consulte o código FullyShardedDataParallel do PyTorch.

Para aqueles interessados nas semelhanças e diferenças entre FSDP e DeepSpeed, confira o guia de conceitos aqui!

Update on GitHub