Accelerate documentation
Paralelismo de Dados Totalmente Fragmentado
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: falseaccelerate 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.distcpPara 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_SHARDcorresponde aoZeRO Stage-3do DeepSpeed. Faz o particionamento (sharding) dos estados do otimizador, dos gradientes e dos parâmetros.SHARD_GRAD_OPcorresponde aoZeRO Stage-2do DeepSpeed. Faz o particionamento dos estados do otimizador e dos gradientes.NO_SHARDcorresponde aZeRO Stage-0. Não há particionamento, cada GPU possui uma cópia completa do modelo, dos estados do otimizador e dos gradientes.HYBRID_SHARDcorresponde aZeRO++ Stage-3, no qualzero_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()eaccelerator.load_state()resultarão em comportamento incorreto/imprevisto. - Este recurso é incompatível com
--predict_with_generateno scriptrun_translation.pyda bibliotecaTransformers.
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.
Update on GitHubPara aqueles interessados nas semelhanças e diferenças entre FSDP e DeepSpeed, confira o guia de conceitos aqui!