Accelerate documentation
Utilitaires de parallélisme de données entièrement fragmentées
Utilitaires de parallélisme de données entièrement fragmentées
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
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
< source >( 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éfautTrue) — Indique s'il faut enregistrer les poids fusionnés avec safetensors (recommandé). - remove_checkpoint_dir (
bool, facultatif, valeur par défautFalse) — 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
< source >( 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éfaut1) — 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 unestr, soit une instance detorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Est déprécié au profit dereshard_after_forward. - reshard_after_forward (
Union[str, torch.distributed.fsdp.ShardingStrategy, bool], par défaut'FULL_SHARD'pourfsdp_version=1etTruepourfsdp_version=2) — Stratégie de sharding à utiliser. Doit être un bool sifsdp_versionest défini à 2, sinon unestrou une instance detorch.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 unestr, soit une instance detorch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch. - mixed_precision_policy (
Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], par défautNone) — Une configuration pour activer l’entraînement en précision mixte avec FullyShardedDataParallel. Si vous passez undict, il doit contenir les clés suivantes :param_dtype,reduce_dtypeetbuffer_dtype. Il peut également être une instance detorch.distributed.fsdp.MixedPrecisionPolicysifsdp_versionest défini sur 2. Si vous passez unstr, il doit être l’une des valeurs suivantes : fp8, fp16, bf16, fp32, et sert à définirparam_dtype,reduce_dtypeetbuffer_dtype. - auto_wrap_policy (
Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults toNO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one oftransformer_based_wrap,size_based_wrap, orno_wrap. Seetorch.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éfautFalse) — Indique s'il faut décharger les paramètres sur le CPU. Doit être soit unbool, soit une instance detorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadou detorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicysifsdp_versionest défini à 2. - ignored_modules (
Optional[Union[Iterable[torch.nn.Module], str]], par défautNone) — 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. Sifsdp_versionest 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_dictousharded_state_dict. - state_dict_config (
Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], par défautNone) — Configuration du state dict à utiliser. Elle est déterminée en fonction destate_dict_typesi elle n’est pas fournie. - optim_state_dict_config (
Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], par défautNone) — Configuration du dictionnaire d'état de l'optimiseur à utiliser. Elle est déterminée en fonction destate_dict_typesi elle n'est pas fournie. - limit_all_gathers (
bool, par défautTrue) — 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éfautFalse) — Indique s'il faut utiliser les paramètres d'origine pour l'optimiseur. - param_init_fn (
Optional[Callable[[torch.nn.Module], None], par défautNone) — UnCallable[torch.nn.Module] -> Nonequi spécifie comment initialiser sur un appareil réel les modules actuellement sur l'appareil méta. Applicable uniquement lorsquesync_module_statesestTrue. Par défaut, c'est unlambdaqui appelleto_emptysur le module. - sync_module_states (
bool, par défautFalse) — 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 estFalse, sauf sicpu_ram_efficient_loadingestTrue, auquel cas elle est activée de force. - forward_prefetch (
bool, par défautFalse) — 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éfautFalse) — 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éfautNone) — 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_statesdoit êtreTrue. - transformer_cls_names_to_wrap (
Optional[List[str]], par défautNone) — Une liste de noms de classes de couches de transformeurs à encapsuler. Applicable uniquement lorsqueauto_wrap_policyesttransformer_based_wrap. - min_num_params (
Optional[int], par défautNone) — Le nombre minimal de paramètres qu'un module doit posséder pour être encapsulé. Applicable uniquement lorsqueauto_wrap_policyestsize_based_wrap.
Ce plugin est utilisé pour activer le parallélisme de données entièrement fragmentées.
À 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
Définit la politique de précision mixte pour FSDP
Définissez la configuration du dictionnaire d'état en fonction du StateDictType.
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
< source >( 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éfautFalse) — 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
< source >( 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é pardata_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
< source >( acceleratormodel: Module ) → torch.nn.Module
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.