Accelerate documentation

Fully Sharded Data Parallel

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Fully Sharded Data Parallel

Pour accélérer l’entraînement de très grands modèles sur des tailles de lot plus importantes, nous pouvons utiliser un modèle de parallélisme de données entièrement fragmenté. Ce type de paradigme de parallélisme de données permet de traiter plus de données et des modèles plus volumineux en fragmentant les états de l’optimiseur, les gradients et les paramètres. Pour en savoir plus à ce sujet et sur ses avantages, consultez le blog sur le Fully Sharded Data Parallel. Nous avons intégré la dernière fonctionnalité d’entraînement Fully Sharded Data Parallel (FSDP) de PyTorch. Il vous suffit de l’activer via la configuration.

Fonctionnement par défaut

Sur votre machine (ou vos machines), exécutez simplement :

accelerate config

et répondre aux questions posées. Cela génère un fichier de configuration qui sera utilisé automatiquement pour définir correctement les options par défaut lors de

accelerate launch my_script.py --args_to_my_script

Par exemple, voici comment exécuter examples/nlp_example.py (depuis la racine du dépôt) avec FSDP activé :

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

Actuellement, Accelerate prend en charge la configuration suivante via l'interface en ligne de commande :

fsdp_sharding_strategy : [1] FULL_SHARD (met en tranches les états de l'optimiseur, les gradients et les paramètres), [2] SHARD_GRAD_OP (met en tranches les états de l'optimiseur et les gradients), [3] NO_SHARD (DDP), [4] HYBRID_SHARD (met en tranches les états de l'optimiseur, les gradients et les paramètres au sein de chaque nœud, chaque nœud disposant d'une copie complète), [5] HYBRID_SHARD_ZERO2 (met en tranches les états de l'optimiseur et les gradients au sein de chaque nœud, chaque nœud disposant d'une copie complète). Pour plus d'informations, veuillez consulter la documentation officielle de PyTorch.

fsdp_offload_params : Détermine s'il faut décharger les paramètres et les gradients sur le CPU

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

fsdp_transformer_layer_cls_to_wrap : Applicable uniquement à Transformers. Lors de l'utilisation de fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP, l'utilisateur peut fournir une chaîne de noms de classes de couches de transformer séparées par des virgules (sensible à la casse) à envelopper, par exemple BertLayer, GPTJBlock, T5Block, BertLayer,BertEmbeddings,BertSelfOutput. C'est important car les sous-modules qui partagent des poids (par exemple, les couches d'embedding) ne doivent pas se retrouver dans des unités FSDP enveloppées différentes. Avec cette politique, l'enveloppement se produit pour chaque bloc contenant une Multi-Head Attention suivie de quelques couches MLP. Les couches restantes, y compris les embeddings partagés, sont commodément enveloppées dans la même unité FSDP la plus externe. Utilisez donc cela pour les modèles basés sur des transformers. Vous pouvez utiliser model._no_split_modules pour les modèles Transformer en répondant yes à Do you want to use the model's_no_split_modulesto wrap. It will try to usemodel._no_split_modules` when possible.

fsdp_min_num_params : nombre minimal de paramètres lors de l'utilisation de fsdp_auto_wrap_policy=SIZE_BASED_WRAP.

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

fsdp_forward_prefetch : si True, FSDP effectue explicitement le préchargement (prefetch) du prochain all-gather pendant l’exécution de la passe avant. À n’utiliser que pour les modèles à graphe statique, car le préchargement suit l’ordre d’exécution de la première itération. Autrement dit, si l’ordre des sous-modules change dynamiquement pendant l’exécution du modèle, ne pas activer cette fonctionnalité.

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

fsdp_use_orig_params : Si True, autorise des requires_grad non uniformes lors de l’initialisation, ce qui signifie la prise en charge de paramètres figés et entraînables alternés. Ce paramètre est utile dans des cas tels que l’ajustement fin efficace en termes de paramètres, comme discuté dans ce billet. Cette option permet également d’avoir plusieurs groupes de paramètres d’optimiseur. Il doit être True lors de la création d’un optimiseur avant de préparer/envelopper le modèle avec FSDP.

fsdp_cpu_ram_efficient_loading : Ne s’applique qu’aux modèles Transformers. Si True, seul le premier processus charge le checkpoint du modèle pré-entraîné, tandis que tous les autres processus ont des poids vides. Cette option doit être définie sur False si vous rencontrez des erreurs lors du chargement du modèle Transformers pré-entraîné via la méthode from_pretrained. Lorsque ce paramètre est True, fsdp_sync_module_states doit également être True, sinon tous les processus, à l’exception du processus principal, auront des poids aléatoires, ce qui entraînera un comportement inattendu pendant l’entraînement. Pour que cela fonctionne, assurez-vous que le groupe de processus distribués est initialisé avant d’appeler la méthode from_pretrained de Transformers. Lorsque vous utilisez l’API Trainer, le groupe de processus distribués est initialisé lors de la création d’une instance de la classe TrainingArguments.

fsdp_sync_module_states : si True, chaque unité FSDP enveloppée individuellement diffusera les paramètres du module depuis le rang 0.

Pour un contrôle supplémentaire et plus nuancé, vous pouvez spécifier d'autres paramètres FSDP via FullyShardedDataParallelPlugin. Lors de la création de l'objet FullyShardedDataParallelPlugin, transmettez-lui les paramètres qui ne faisaient pas partie de la configuration accelerate ou que vous souhaitez remplacer. Les paramètres FSDP seront sélectionnés en fonction du fichier de configuration accelerate ou des arguments de la commande de lancement, et les autres paramètres que vous passerez directement via l'objet FullyShardedDataParallelPlugin les définiront ou les remplaceront.

Voici un exemple :

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)

Enregistrer et charger

La nouvelle méthode recommandée pour effectuer le checkpointing avec des modèles FSDP consiste à utiliser SHARDED_STATE_DICT en tant que StateDictType lors de la configuration d'accelerate. Voici un extrait de code pour enregistrer en utilisant l'utilitaire save_state d'accelerate.

accelerator.save_state("ckpt")

Inspectez le dossier de point de contrôle pour voir le modèle et l'optimiseur sous forme de fragments par processus :

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

Pour les recharger afin de reprendre l'entraînement, utilisez l'utilitaire load_state d'accelerate

accelerator.load_state("ckpt")

Lors de l'utilisation de save_pretrained de transformers, passez state_dict=accelerator.get_state_dict(model) pour enregistrer le dictionnaire d'état du modèle. Voici un exemple :

  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 appelle l’implémentation sous-jacente model.state_dict en utilisant le gestionnaire de contexte FullStateDictConfig(offload_to_cpu=True, rank0_only=True) afin d’obtenir le state dict uniquement pour le rang 0, qui sera ensuite transféré sur le CPU.

Vous pouvez ensuite passer state à la méthode save_pretrained. Il existe plusieurs modes pour StateDictType et FullStateDictConfig que vous pouvez utiliser pour contrôler le comportement de state_dict. Pour plus d’informations, consultez la documentation PyTorch.

Si vous choisissez d'utiliser StateDictType.SHARDED_STATE_DICT, les poids du modèle lors de Accelerator.save_state seront répartis dans n fichiers pour chaque sous-partition du modèle. Pour les fusionner à nouveau en un seul dictionnaire afin de les recharger dans le modèle après l'entraînement, vous pouvez utiliser l'utilitaire 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)

La sortie finale sera ensuite enregistrée dans model.safetensors ou pytorch_model.bin (si safe_serialization=False est transmis).

Cela peut également être appelé via l'interface en ligne de commande :

accelerate merge-weights pytorch_model_fsdp_0/ output_path

Correspondance entre les stratégies de fractionnement FSDP et les stades ZeRO de DeepSpeed

  • FULL_SHARD correspond à ZeRO Stage-3 de DeepSpeed. Il sharde les états de l’optimiseur, les gradients et les paramètres.
  • SHARD_GRAD_OP correspond à ZeRO Stage-2 de DeepSpeed. Il met en tranches les états de l’optimiseur et les gradients.
  • NO_SHARD correspond à ZeRO Stage-0. Aucun fractionnement : chaque GPU possède une copie complète du modèle, des états de l’optimiseur et des gradients.
  • HYBRID_SHARD correspond à ZeRO++ Stage-3 où zero_hpz_partition_size=<num_gpus_per_node>. Ici, cela sharde les états de l’optimiseur, les gradients et les paramètres au sein de chaque nœud, tandis que chaque nœud possède une copie complète.

Quelques points de vigilance

  • En cas de plusieurs modèles, passez les optimiseurs à l’appel accelerator.save_state() dans le même ordre que les modèles correspondants, sinon accelerator.load_state() entraîneront un comportement incorrect ou inattendu.
  • Cette fonctionnalité est incompatible avec --predict_with_generate dans le script run_translation.py de la bibliothèque Transformers.

Pour un contrôle plus fin, les utilisateurs peuvent utiliser le FullyShardedDataParallelPlugin. Après avoir créé une instance de cette classe, ils peuvent la passer à l'instantiation de la classe Accelerator. Pour plus d'informations sur ces options, veuillez consulter le code FullyShardedDataParallel de PyTorch.

Pour ceux qui s'intéressent aux similitudes et aux différences entre FSDP et DeepSpeed, consultez le guide des concepts ici !

Update on GitHub