# Utilitaires de parallélisme de données entièrement fragmentées

## enable_fsdp_ram_efficient_loading[[accelerate.utils.enable_fsdp_ram_efficient_loading]]

#### accelerate.utils.enable_fsdp_ram_efficient_loading[[accelerate.utils.enable_fsdp_ram_efficient_loading]]

```python
accelerate.utils.enable_fsdp_ram_efficient_loading()
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/fsdp_utils.py#L40)

Active le chargement efficace en RAM des modèles Hugging Face pour FSDP dans l'environnement.

## disable_fsdp_ram_efficient_loading[[accelerate.utils.disable_fsdp_ram_efficient_loading]]

#### accelerate.utils.disable_fsdp_ram_efficient_loading[[accelerate.utils.disable_fsdp_ram_efficient_loading]]

```python
accelerate.utils.disable_fsdp_ram_efficient_loading()
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/fsdp_utils.py#L50)

Désactive le chargement efficace en RAM des modèles Hugging Face pour FSDP dans l'environnement.

## merge_fsdp_weights[[accelerate.utils.merge_fsdp_weights]]

#### accelerate.utils.merge_fsdp_weights[[accelerate.utils.merge_fsdp_weights]]

```python
accelerate.utils.merge_fsdp_weights(checkpoint_dir: str, output_path: str, safe_serialization: bool = True, remove_checkpoint_dir: bool = False)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/fsdp_utils.py#L486)

**Paramètres :**

checkpoint_dir (`str`) : Le répertoire contenant les points de contrôle FSDP (peut être soit le modèle, soit l'optimiseur).

output_path (`str`) : Le chemin pour enregistrer le point de contrôle fusionné.

safe_serialization (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut enregistrer les poids fusionnés avec safetensors (recommandé).

remove_checkpoint_dir (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut supprimer le répertoire du point de contrôle après la fusion.

Fusionner les poids des points de contrôle de modèle FSDP fractionnés en un point de contrôle unique. À utiliser si `SHARDED_STATE_DICT` a été utilisé pour le modèle. Les poids seront enregistrés dans `{output_path}/model.safetensors` si `safe_serialization`, sinon dans `pytorch_model.bin`.

Note : il s'agit d'un processus limité par le CPU.

## FullyShardedDataParallelPlugin[[accelerate.FullyShardedDataParallelPlugin]]

#### accelerate.FullyShardedDataParallelPlugin[[accelerate.FullyShardedDataParallelPlugin]]

```python
accelerate.FullyShardedDataParallelPlugin(fsdp_version: int = None, sharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = None, reshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = None, backward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = None, mixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = None, auto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = None, cpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = None, ignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = None, state_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = None, state_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = None, optim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = None, limit_all_gathers: bool = True, use_orig_params: bool | None = None, param_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = None, sync_module_states: bool | None = None, forward_prefetch: bool = None, activation_checkpointing: bool = None, activation_checkpointing_offload: bool = None, cpu_ram_efficient_loading: bool = None, transformer_cls_names_to_wrap: list[str] | None = None, min_num_params: int | None = None)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1465)

**Paramètres :**

fsdp_version (`int`, par défaut `1`) : La version de FSDP à utiliser. Par défaut, 1. Si défini sur 2, le lanceur s'attend à ce que la configuration soit convertie au format FSDP2.

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`, par défaut `'FULL_SHARD'`) : Stratégie de sharding à utiliser. Doit être soit une `str`, soit une instance de `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`. Obsolète au profit de `reshard_after_forward`.

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`, par défaut `'FULL_SHARD'` pour `fsdp_version=1` et `True` pour `fsdp_version=2`) : Stratégie de sharding à utiliser. Doit être un bool si `fsdp_version` est défini à 2, sinon un `str` ou une instance de `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`.

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`, par défaut `'NO_PREFETCH'`) : Stratégie de préchargement en arrière-plan à utiliser. Doit être soit une `str`, soit une instance de `torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch`.

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`, par défaut `None`) : Une configuration pour activer l’entraînement en précision mixte avec FullyShardedDataParallel. Si vous passez un `dict`, il doit contenir les clés suivantes : `param_dtype`, `reduce_dtype` et `buffer_dtype`. Il peut être une instance de `torch.distributed.fsdp.MixedPrecisionPolicy` si `fsdp_version` est défini sur 2. Si vous passez un `str`, il doit être l’une des valeurs suivantes : fp8, fp16, bf16, fp32, et est utilisé pour définir `param_dtype`, `reduce_dtype` et `buffer_dtype`.

auto_wrap_policy (`Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults to `NO_WRAP`) : A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of `transformer_based_wrap`, `size_based_wrap`, or `no_wrap`. See `torch.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]`, par défaut `False`) : Indique s'il faut décharger les paramètres sur le CPU. Doit être soit un `bool`, soit une instance de `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload` ou de `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy` si `fsdp_version` est défini sur 2.

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`, par défaut `None`) : Une liste de modules à ignorer lors de l’encapsulation avec FSDP. En passant une chaîne de caractères, les modules sont appariés par nom à l’aide d’une correspondance complète par expression régulière. Si `fsdp_version` est défini sur 2, les modules sont convertis en paramètres et utilisés.

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`, par défaut `'FULL_STATE_DICT'`) : Type de state dict à utiliser. S'il s'agit d'une chaîne de caractères, elle doit être l'une des valeurs suivantes : `full_state_dict`, `local_state_dict` ou `sharded_state_dict`.

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`, par défaut `None`) : Configuration du state dict à utiliser. Elle est déterminée en fonction de `state_dict_type` si elle n'est pas fournie.

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`, par défaut `None`) : Configuration du dictionnaire d'état de l'optimiseur à utiliser. Elle est déterminée en fonction de `state_dict_type` si elle n'est pas fournie.

limit_all_gathers (`bool`, par défaut `True`) : Indique si FSDP doit synchroniser explicitement le thread CPU pour éviter un nombre excessif d'opérations all-gather en cours. Ce booléen n'affecte que les stratégies shardées qui planifient des all-gathers. L'activer peut aider à réduire le nombre de tentatives de malloc CUDA.

use_orig_params (`bool`, par défaut `False`) : Indique s'il faut utiliser les paramètres d'origine pour l'optimiseur.

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`, par défaut `None`) : Un `Callable[torch.nn.Module] -> None` qui spécifie comment les modules actuellement sur le périphérique méta doivent être initialisés sur un périphérique réel. Applicable uniquement lorsque `sync_module_states` est `True`. Par défaut, c'est un `lambda` qui appelle `to_empty` sur le module.

sync_module_states (`bool`, par défaut `False`) : Indique si chaque unité FSDP enveloppée individuellement doit diffuser les paramètres du module depuis le rang 0 pour garantir qu'ils sont identiques sur tous les rangs après l'initialisation. La valeur par défaut est `False`, sauf si `cpu_ram_efficient_loading` est `True`, auquel cas elle est activée de force.

forward_prefetch (`bool`, par défaut `False`) : Indique si FSDP doit précharger explicitement le prochain all-gather pendant l'exécution du passage avant. À n'utiliser qu'avec des graphiques statiques.

activation_checkpointing (`bool`, par défaut `False`) : Une technique permettant de réduire l'utilisation de la mémoire en effaçant les activations de certaines couches et en les recalculant lors d'une passe arrière. Concrètement, cela échange un temps de calcul supplémentaire contre une réduction de l'utilisation de la mémoire.

cpu_ram_efficient_loading (`bool`, par défaut `None`) : Si True, seul le premier processus charge le point de contrôle du modèle préentraîné, tandis que tous les autres processus ont des poids vides. Applicable uniquement pour Transformers. Lors de l'utilisation de cette option, `sync_module_states` doit être `True`.

transformer_cls_names_to_wrap (`Optional[List[str]]`, par défaut `None`) : Une liste de noms de classes de couches de transformeur à encapsuler. Applicable uniquement lorsque `auto_wrap_policy` est `transformer_based_wrap`.

min_num_params (`Optional[int]`, par défaut `None`) : Le nombre minimal de paramètres qu'un module doit posséder pour être encapsulé. Applicable uniquement lorsque `auto_wrap_policy` est `size_based_wrap`.

Ce plugin est utilisé pour activer le parallélisme de données entièrement fragmentées.

#### set_auto_wrap_policy[[accelerate.FullyShardedDataParallelPlugin.set_auto_wrap_policy]]

```python
set_auto_wrap_policy(model)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1941)

À partir de `model`, crée une `auto_wrap_policy` basée sur la politique transmise et sur la possibilité d'utiliser `transformer_cls_to_wrap`

#### set_mixed_precision[[accelerate.FullyShardedDataParallelPlugin.set_mixed_precision]]

```python
set_mixed_precision(mixed_precision, buffer_autocast = False, override = False)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1981)

Définit la politique de précision mixte pour FSDP

#### set_state_dict_type[[accelerate.FullyShardedDataParallelPlugin.set_state_dict_type]]

```python
set_state_dict_type(state_dict_type = None)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1896)

Définissez la configuration du dictionnaire d'état en fonction du `StateDictType`.

#### validate_mixed_precision_policy[[accelerate.FullyShardedDataParallelPlugin.validate_mixed_precision_policy]]

```python
validate_mixed_precision_policy()
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2029)

Valide la politique de précision mixte, abstraite afin d'éviter d'importer les dépendances si elles ne sont pas nécessaires.

## fsdp2_load_full_state_dict[[accelerate.utils.fsdp2_load_full_state_dict]]

#### accelerate.utils.fsdp2_load_full_state_dict[[accelerate.utils.fsdp2_load_full_state_dict]]

```python
accelerate.utils.fsdp2_load_full_state_dict(accelerator, model: Module, full_sd: dict, cpu_offload: bool = False)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/fsdp_utils.py#L584)

**Paramètres :**

accelerator (`Accelerator`) : l'instance de l'accélérateur

model (`torch.nn.Module`) : Le modèle dans lequel charger le state dict, censé être sur le meta device, sinon un pic de VRAM peut se produire

full_sd (`dict`) : Le dictionnaire d'état complet à charger, ne peut être présent que sur le rang 0

cpu_offload (`bool`, par défaut `False`) : Si True, déplace les paramètres fractionnés vers le CPU après la distribution. Requis lorsque le déchargement CPU de FSDP est activé. Les tampons et les paramètres ignorés restent sur l'appareil d'accélération.

Charge le dictionnaire d'état complet (éventuellement uniquement sur le rang 0) dans le modèle shardé. Cela est réalisé en diffusant les paramètres depuis le rang 0 vers tous les autres rangs. Cette fonction modifie le modèle en place.

## fsdp2_switch_optimizer_parameters[[accelerate.utils.fsdp2_switch_optimizer_parameters]]

#### accelerate.utils.fsdp2_switch_optimizer_parameters[[accelerate.utils.fsdp2_switch_optimizer_parameters]]

```python
accelerate.utils.fsdp2_switch_optimizer_parameters(optimizer: Optimizer, mapping: dict)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/fsdp_utils.py#L658)

**Paramètres :**

optimizer (`torch.optim.Optimizer`) : instance d'optimiseur contenant les paramètres originaux du modèle

mapping (`dict`) : Correspondance entre le pointeur de données du paramètre d'origine (ou l'identité pour les paramètres meta) et le paramètre fragmenté.

**Levée :** ``KeyError``

- ``KeyError`` -- Si un paramètre de l'optimiseur n'a pas pu être converti en sa version shardée. Cela ne devrait jamais se produire et indique un bug. Si nous avions conservé les paramètres d'origine au lieu de lever l'exception, l'entraînement n'aurait pas été numériquement correct et les poids n'auraient pas été mis à jour.

Bascule les paramètres de l'optimiseur vers de nouveaux paramètres (paramètres sharded dans le cas habituel). Cette fonction modifie l'optimiseur en place.

## fsdp2_prepare_model[[accelerate.utils.fsdp2_prepare_model]]

#### accelerate.utils.fsdp2_prepare_model[[accelerate.utils.fsdp2_prepare_model]]

```python
accelerate.utils.fsdp2_prepare_model(accelerator, model: Module)
```

[Source](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/fsdp_utils.py#L740)

**Paramètres :**

accelerator (`Accelerator`) : l'instance de l'accélérateur

model (`torch.nn.Module`) : Le modèle à préparer

**Retourne :** `torch.nn.Module`

Modèle préparé

Prépare le modèle pour FSDP2 sur place. Renvoie également le modèle afin d'éviter tout mauvais usage du modèle d'origine.

## fsdp2_prepare_auto_wrap_policy

