Accelerate documentation

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

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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

enable_fsdp_ram_efficient_loading

accelerate.utils.enable_fsdp_ram_efficient_loading

< >

( )

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

< >

( )

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

< >

( checkpoint_dir: stroutput_path: strsafe_serialization: bool = Trueremove_checkpoint_dir: bool = False )

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 où enregistrer le point de contrôle fusionné.
  • safe_serialization (bool, facultatif, valeur par défaut True) — Indique s'il faut enregistrer les poids fusionnés avec safetensors (recommandé).
  • remove_checkpoint_dir (bool, facultatif, valeur par défaut False) — Indique s'il faut supprimer le répertoire de 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

classe accelerate.FullyShardedDataParallelPlugin

< >

( fsdp_version: int = Nonesharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = Nonereshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = Nonebackward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = Nonemixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = Noneauto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = Nonecpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = Noneignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = Nonestate_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = Nonestate_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = Noneoptim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = Nonelimit_all_gathers: bool = Trueuse_orig_params: bool | None = Noneparam_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = Nonesync_module_states: bool | None = Noneforward_prefetch: bool = Noneactivation_checkpointing: bool = Noneactivation_checkpointing_offload: bool = Nonecpu_ram_efficient_loading: bool = Nonetransformer_cls_names_to_wrap: list[str] | None = Nonemin_num_params: int | None = None )

Paramètres

  • fsdp_version (int, par défaut 1) — La version de FSDP à utiliser. Par défaut, 1. Si défini à 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. Est déprécié 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 une 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 à 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 également ê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 sert à 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 à 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 afin d'éviter un nombre excessif d'opérations all-gather en cours. Ce booléen n'affecte que les stratégies shardées qui planifient les all-gathers. L'activation de cette option 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 initialiser sur un appareil réel les modules actuellement sur l'appareil méta. 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 de la passe 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 passée 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 checkpoint 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 transformeurs à 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

< >

( model )

À 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

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

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

set_state_dict_type

< >

( state_dict_type = None )

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

validate_mixed_precision_policy

< >

( )

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

< >

( acceleratormodel: Modulefull_sd: dictcpu_offload: bool = False )

Paramètres

  • accelerator (Accelerator) — L'instance d'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é.

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

< >

( optimizer: Optimizermapping: dict )

Paramètres

  • optimizer (torch.optim.Optimizer) — Instance d'optimiseur contenant les paramètres originaux du modèle
  • mapping (dict) — Correspondance entre le paramètre d’origine (spécifié par data_ptr) et le paramètre fractionné

Lève

KeyError

  • KeyError — Si un paramètre de l’optimiseur n’a pas pu être basculé vers 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

< >

( acceleratormodel: Module ) → torch.nn.Module

Paramètres

  • accelerator (Accelerator) — L'instance d'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

Update on GitHub