# 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](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/). 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 :

```bash
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

```bash
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é :

```bash
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
```

```bash
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](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.ShardingStrategy).

`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_modules` to wrap. It will try to use `model._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](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019). 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 :

```py
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. Le fragment de code ci-dessous montre comment enregistrer en utilisant l'utilitaire `save_state` d'accelerate.

```py
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

```py
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 :

```diff
  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](https://pytorch.org/docs/stable/fsdp.html).

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` :

```py
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 :
```bash
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](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) de PyTorch.

    Pour ceux qui s'intéressent aux similitudes et aux différences entre FSDP et DeepSpeed, consultez le [guide des concepts ici](../concept_guides/fsdp_and_deepspeed) !
    

