Hugging Face's logo

Accelerate documentation

Fonctions et classes utilitaires

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

Fonctions et classes utilitaires

Voici une variété de fonctions utilitaires fournies par 🤗 Accelerate, classées par cas d’usage.

Constantes

Constantes utilisées dans l’ensemble de 🤗 Accelerate à titre de référence

Les éléments suivants sont des constantes utilisées lors de l'utilisation de Accelerator.save_state()

utils.MODEL_NAME: "pytorch_model" utils.OPTIMIZER_NAME: "optimizer" utils.RNG_STATE_NAME: "random_states" utils.SCALER_NAME: "scaler.pt utils.SCHEDULER_NAME: "scheduler

Les éléments suivants sont des constantes utilisées lors de l'utilisation de Accelerator.save_model()

utils.WEIGHTS_NAME: "pytorch_model.bin" utils.SAFE_WEIGHTS_NAME: "model.safetensors" utils.WEIGHTS_INDEX_NAME: "pytorch_model.bin.index.json" utils.SAFE_WEIGHTS_INDEX_NAME: "model.safetensors.index.json"

Classes de données

Ce sont des dataclasses de base utilisées tout au long de 🤗 Accelerate et elles peuvent être passées en tant que paramètres.

Autonome

Ce sont des dataclasses autonomes utilisées pour les vérifications, telles que le type de système distribué utilisé

classe accelerate.utils.ComputeEnvironment

< >

( *values )

Représente un type d'environnement de calcul.

Valeurs :

  • LOCAL_MACHINE — matériel de cluster privé/personnalisé.
  • AMAZON_SAGEMAKER — Amazon SageMaker en tant qu’environnement de calcul.

classe accelerate.DistributedType

< >

( *values )

Représente un type d'environnement distribué.

Valeurs :

  • NON — Pas un environnement distribué, juste un processus unique.
  • MULTI_CPU — Réparti sur plusieurs nœuds CPU.
  • MULTI_GPU — Réparti sur plusieurs GPU.
  • MULTI_MLU — Réparti sur plusieurs MLU.
  • MULTI_SDAA — Réparti sur plusieurs SDAAs.
  • MULTI_MUSA — Distribué sur plusieurs MUSAs.
  • MULTI_NPU — Réparti sur plusieurs NPU.
  • MULTI_XPU — Réparti sur plusieurs XPU.
  • MULTI_HPU — Réparti sur plusieurs HPU.
  • MULTI_NEURON — Réparti sur plusieurs cœurs Neuron.
  • DEEPSPEED — Utilisation de DeepSpeed.
  • FSDP — Utilisation de Fully Sharded Data Parallelism (FSDP).
  • XLA — Utilisation de TorchXLA.
  • MEGATRON_LM — Utilisation de Megatron-LM.

classe accelerate.utils.DynamoBackend

< >

( *values )

Représente un backend dynamo (voir https://pytorch.org/docs/stable/torch.compiler.html).

Valeurs :

  • NON — N'utilisez pas torch dynamo.
  • EAGER — Utilise PyTorch pour exécuter le GraphModule extrait. C'est très utile pour déboguer les problèmes de TorchDynamo.
  • AOT_EAGER — Utilise AotAutograd sans compilateur, c’est-à-dire en s’appuyant uniquement sur l’exécution eager de PyTorch pour les graphes avant et arrière extraits par AotAutograd. Cette option est utile pour le débogage et il est peu probable qu’elle apporte des gains de vitesse.
  • INDUCTOR — Utilise le backend TorchInductor avec AotAutograd et cudagraphs en s’appuyant sur des noyaux Triton générés par codegen. En savoir plus
  • AOT_TS_NVFUSER — nvFuser avec AotAutograd/TorchScript. En savoir plus
  • NVPRIMS_NVFUSER — nvFuser avec PrimTorch. En savoir plus
  • CUDAGRAPHS — cudagraphs avec AotAutograd. En savoir plus
  • OFI — Utilise Torchscript optimize_for_inference. Inférence uniquement. En savoir plus
  • FX2TRT — Utilise Nvidia TensorRT pour l’optimisation de l’inférence. Inférence uniquement. En savoir plus
  • ONNXRT — Utilise ONNXRT pour l'inférence sur CPU/GPU. Inférence uniquement. En savoir plus
  • TENSORRT — Utilise ONNXRT pour exécuter TensorRT afin d’optimiser l’inférence. En savoir plus
  • AOT_TORCHXLA_TRACE_ONCE — Utilise Pytorch/XLA avec l’optimisation TorchDynamo, pour l’entraînement. En savoir plus
  • TORCHXLA_TRACE_ONCE — Utilise Pytorch/XLA avec l’optimisation TorchDynamo, pour l’inférence. En savoir plus
  • TVM — Utilise Apache TVM pour les optimisations d'inférence. En savoir plus
  • HPU_BACKEND — Utilise le backend HPU pour les optimisations d’inférence.
  • NEURON — Utilise le backend AWS Neuron pour Trainium/Inferentia.

classe accelerate.utils.LoggerType

< >

( *values )

Représente un type de traceur d'expériences pris en charge

Valeurs :

  • TOUT — tous les traceurs disponibles dans l'environnement et pris en charge
  • TENSORBOARD — TensorBoard en tant que traceur d'expériences
  • WANDB — wandb en tant que traceur d'expérimentations
  • TRACKIO — trackio en tant que traceur d'expériences
  • COMETML — comet_ml en tant que traceur d'expériences
  • MLFLOW — mlflow en tant que traceur d'expériences
  • CLEARML — clearml en tant que traceur d'expériences
  • DVCLIVE — dvclive en tant que traceur d'expériences
  • SWANLAB — swanlab en tant que traceur d'expériences

classe accelerate.utils.PrecisionType

< >

( *values )

Représente un type de précision utilisé sur les valeurs à virgule flottante

Valeurs :

  • NON — utilisation de la pleine précision (FP32)
  • FP16 — utilisation de la demi-précision
  • BF16 — utilisation de la précision brain floating point

classe accelerate.utils.RNGType

< >

( *values )

classe accelerate.utils.SageMakerDistributedType

< >

( *values )

Représente un type d'environnement distribué.

Valeurs :

  • NON — Pas un environnement distribué, juste un processus unique.
  • DATA_PARALLEL — utilisation de la parallélisation distribuée des données de sagemaker.
  • MODEL_PARALLEL — utilisation de la parallélisation distribuée des modèles de sagemaker.

Kwargs

Ce sont des arguments configurables pour des interactions spécifiques au sein de l’écosystème PyTorch, que Accelerate gère en interne.

classe accelerate.AutocastKwargs

< >

( enabled: bool = Truecache_enabled: bool | None = None )

Utilisez cet objet dans votre Accelerator pour personnaliser le comportement de torch.autocast. Veuillez consulter la documentation de ce context manager pour plus d’informations sur chaque argument.

Exemple :

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

kwargs = AutocastKwargs(cache_enabled=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])

classe accelerate.DistributedDataParallelKwargs

< >

( dim: int = 0broadcast_buffers: bool = Truebucket_cap_mb: int = 25find_unused_parameters: bool = Falsecheck_reduction: bool = Falsegradient_as_bucket_view: bool = Falsestatic_graph: bool = Falsecomm_hook: DDPCommunicationHookType = <DDPCommunicationHookType.NO: 'no'>comm_wrapper: typing.Literal[<DDPCommunicationHookType.NO: 'no'>, <DDPCommunicationHookType.FP16: 'fp16'>, <DDPCommunicationHookType.BF16: 'bf16'>] = <DDPCommunicationHookType.NO: 'no'>comm_state_option: dict = <factory> )

Utilisez cet objet dans votre Accelerator pour personnaliser la manière dont votre modèle est encapsulé dans un torch.nn.parallel.DistributedDataParallel. Veuillez consulter la documentation de ce wrapper pour plus d’informations sur chaque argument.

Exemple :

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])

classe accelerate.GradScalerKwargs

< >

( init_scale: float = 65536.0growth_factor: float = 2.0backoff_factor: float = 0.5growth_interval: int = 2000enabled: bool = True )

Utilisez cet objet dans votre Accelerator pour personnaliser le comportement de la précision mixte, en particulier la manière dont le torch.amp.GradScaler ou le torch.cuda.amp.GradScaler utilisé est créé. Veuillez consulter la documentation de ce scaler pour plus d’informations sur chaque argument.

Exemple :

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

kwargs = GradScalerKwargs(backoff_factor=0.25)
accelerator = Accelerator(kwargs_handlers=[kwargs])

classe accelerate.InitProcessGroupKwargs

< >

( backend: str | None = 'nccl'init_method: str | None = Nonetimeout: datetime.timedelta | None = None )

Utilisez cet objet dans votre Accelerator pour personnaliser l’initialisation des processus distribués. Veuillez consulter la documentation de cette méthode pour plus d’informations sur chaque argument.

Note : Si timeout est défini sur None, la valeur par défaut sera basée sur la configuration de backend.

from datetime import timedelta
from accelerate import Accelerator
from accelerate.utils import InitProcessGroupKwargs

kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=800))
accelerator = Accelerator(kwargs_handlers=[kwargs])

classe accelerate.utils.KwargsHandler

< >

( )

Mixin interne qui implémente une méthode to_kwargs() pour un dataclass.

to_kwargs

< >

( )

Retourne un dictionnaire contenant les attributs dont les valeurs diffèrent des valeurs par défaut de cette classe.

Plugins

Ce sont des plugins qui peuvent être passés à l'objet Accelerator. Bien qu'ils soient définis ailleurs dans la documentation, pour votre confort, tous sont disponibles à consulter ici :

classe accelerate.DeepSpeedPlugin

< >

( hf_ds_config: Any = Nonegradient_accumulation_steps: int = Nonegradient_clipping: float = Nonezero_stage: int = Noneis_train_batch_min: bool = Trueoffload_optimizer_device: str = Noneoffload_param_device: str = Noneoffload_optimizer_nvme_path: str = Noneoffload_param_nvme_path: str = Nonezero3_init_flag: bool = Nonezero3_save_16bit_model: bool = Nonetransformer_moe_cls_names: str = None )

Paramètres

  • hf_ds_config (Any, par défaut None) — Chemin vers le fichier de configuration DeepSpeed, dictionnaire ou objet de la classe accelerate.utils.deepspeed.HfDeepSpeedConfig.
  • gradient_accumulation_steps (int, par défaut None) — Nombre d'étapes pour accumuler les gradients avant de mettre à jour les états de l'optimiseur. Si non défini, utilise directement la valeur de l'Accelerator.
  • gradient_clipping (float, par défaut None) — Active la limitation des gradients avec la valeur indiquée.
  • zero_stage (int, par défaut None) — Les options possibles sont 0, 1, 2, 3. La valeur par défaut est prise de la variable d’environnement.
  • is_train_batch_min (bool, par défaut True) — Si les deux chargeurs de données d'entraînement et d'évaluation sont spécifiés, ce paramètre détermine la train_batch_size.
  • offload_optimizer_device (str, par défaut None) — Les options possibles sont none|cpu|nvme. Applicable uniquement avec les étapes ZeRO 2 et 3.
  • offload_param_device (str, par défaut None) — Les options possibles sont none|cpu|nvme. Applicable uniquement avec ZeRO Stage 3.
  • offload_optimizer_nvme_path (str, par défaut None) — Les options possibles sont /nvme|/local_nvme. Applicable uniquement avec ZeRO Stage 3.
  • offload_param_nvme_path (str, par défaut None) — Les options possibles sont /nvme|/local_nvme. Applicable uniquement avec ZeRO Stage 3.
  • zero3_init_flag (bool, par défaut None) — Indique s'il faut enregistrer le modèle en 16 bits. Applicable uniquement avec ZeRO Stage-3.
  • zero3_save_16bit_model (bool, par défaut None) — Indique s'il faut enregistrer le modèle en 16 bits. Applicable uniquement avec ZeRO Stage-3.
  • transformer_moe_cls_names (str, par défaut None) — Liste de noms de classes de couches MoE de Transformers, séparés par des virgules (sensible à la casse). Par exemple, MixtralSparseMoeBlock, Qwen2MoeSparseMoeBlock, JetMoEAttention, JetMoEBlock, etc.

Ce plugin est utilisé pour intégrer DeepSpeed.

deepspeed_config_process

< >

( prefix = ''mismatches = Noneconfig = Nonemust_match = True**kwargs )

Traitez la configuration DeepSpeed avec les valeurs issues des kwargs.

sélectionner

< >

( _from_accelerator_state: bool = False )

Définit le HfDeepSpeedWeakref pour utiliser la configuration actuelle du plugin deepspeed

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.

classe accelerate.utils.GradientAccumulationPlugin

< >

( num_steps: int = Noneadjust_scheduler: bool = Truesync_with_dataloader: bool = Truesync_each_batch: bool = False )

Paramètres

  • num_steps (int) — Le nombre d'étapes pour lesquelles accumuler les gradients.
  • adjust_scheduler (bool, facultatif, par défaut True) — Indique s'il faut ajuster les étapes du planificateur pour tenir compte du nombre d'étapes accumulées. Doit être True si le planificateur utilisé n'a pas été ajusté pour l'accumulation de gradients.
  • sync_with_dataloader (bool, facultatif, par défaut True) — Indique s'il faut synchroniser la configuration des gradients à la fin du dataloader.
  • sync_each_batch (bool, facultatif) — Indique s'il faut synchroniser la configuration des gradients à chaque lot de données. La valeur True peut réduire les besoins en mémoire lors de l'utilisation de l'accumulation de gradients avec l'entraînement distribué, au détriment de la vitesse.

Un plugin pour configurer le comportement de l'accumulation de gradients. Vous ne pouvez passer qu'un seul de gradient_accumulation_plugin ou gradient_accumulation_steps à Accelerator. Passer les deux provoque une erreur.

Exemple :

from accelerate.utils import GradientAccumulationPlugin

gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=2)
accelerator = Accelerator(gradient_accumulation_plugin=gradient_accumulation_plugin)

classe accelerate.utils.MegatronLMPlugin

< >

( tp_degree: int = Nonepp_degree: int = Noneuse_custom_fsdp: bool = Noneoverlap_cpu_optimizer_d2h_h2d: bool = Noneno_load_optim: bool = Noneeod_mask_loss: bool = Noneno_save_optim: bool = Noneoptimizer_cpu_offload: bool = Noneuse_precision_aware_optimizer: bool = Nonedecoder_last_pipeline_num_layers: int = Nonerecompute_granularity: str = Nonerecompute_method: str = Nonerecompute_num_layers: int = Noneattention_backend: bool = Noneexpert_model_parallel_size: int = Nonecontext_parallel_size: int = Noneattention_dropout: float = Nonehidden_dropout: float = Noneattention_softmax_in_fp32: bool = Noneexpert_tensor_parallel_size: int = Nonecalculate_per_token_loss: bool = Noneuse_rotary_position_embeddings: bool = Nonenum_micro_batches: int = Nonegradient_clipping: float = Nonesequence_parallelism: bool = Nonerecompute_activations: bool = Noneuse_distributed_optimizer: bool = Nonepipeline_model_parallel_split_rank: int = Nonenum_layers_per_virtual_pipeline_stage: int = Noneis_train_batch_min: str = Truetrain_iters: int = Nonetrain_samples: int = Noneweight_decay_incr_style: str = 'constant'start_weight_decay: float = Noneend_weight_decay: float = Nonelr_decay_style: str = 'linear'lr_decay_iters: int = Nonelr_decay_samples: int = Nonelr_warmup_iters: int = Nonelr_warmup_samples: int = Nonelr_warmup_fraction: float = Nonemin_lr: float = 0consumed_samples: list = Noneno_wd_decay_cond: typing.Callable | None = Nonescale_lr_cond: typing.Callable | None = Nonelr_mult: float = 1.0megatron_dataset_flag: bool = Falseseq_length: int = Noneencoder_seq_length: int = Nonedecoder_seq_length: int = Nonetensorboard_dir: str = Noneset_all_logging_options: bool = Falseeval_iters: int = 100eval_interval: int = 1000return_logits: bool = Falsecustom_train_step_class: typing.Any | None = Nonecustom_train_step_kwargs: dict[str, typing.Any] | None = Nonecustom_model_provider_function: typing.Callable | None = Nonecustom_prepare_model_function: typing.Callable | None = Nonecustom_megatron_datasets_provider_function: typing.Callable | None = Nonecustom_get_batch_function: typing.Callable | None = Nonecustom_loss_function: typing.Callable | None = Noneother_megatron_args: dict[str, typing.Any] | None = None )

Paramètres

  • tp_degree (int, par défaut None) — Degré du parallélisme de tenseurs.
  • pp_degree (int, par défaut None) — Degré du parallélisme par pipeline.
  • num_micro_batches (int, par défaut None) — Nombre de micro-lots.
  • gradient_clipping (float, par défaut None) — Valeur de la limitation du gradient basée sur la norme L2 globale (0 pour désactiver).
  • sequence_parallelism (bool, par défaut None) — Active le parallélisme de séquence.
  • recompute_activations (bool, par défaut None) — Active la recomputation sélective des activations.
  • use_distributed_optimizer (bool, par défaut None) — Active l’optimiseur distribué.
  • pipeline_model_parallel_split_rank (int, par défaut None) — Rang où l'encodeur et le décodeur doivent être séparés.
  • num_layers_per_virtual_pipeline_stage (int, par défaut None) — Nombre de couches par étape de pipeline virtuel.
  • is_train_batch_min (str, par défaut True) — Si les deux chargeurs de données tran & eval sont spécifiés, cela déterminera la micro_batch_size.
  • train_iters (int, par défaut None) — Nombre total d’échantillons à entraîner sur l’ensemble des exécutions d’entraînement. Notez que soit train-iters, soit train-samples doit être fourni lors de l’utilisation de MegatronLMDummyScheduler.
  • train_samples (int, par défaut None) — Nombre total d'échantillons à entraîner sur l'ensemble des exécutions d'entraînement. Notez que soit train-iters, soit train-samples doit être fourni lors de l'utilisation de MegatronLMDummyScheduler.
  • weight_decay_incr_style (str, par défaut 'constant') — Fonction d'incrément du weight decay. choices=[“constant”, “linear”, “cosine”].
  • start_weight_decay (float, par défaut None) — Coefficient de décroissance du poids initial pour la régularisation L2.
  • end_weight_decay (float, par défaut None) — Coefficient de décroissance du poids en fin d'exécution pour la régularisation L2.
  • lr_decay_style (str, par défaut 'linear') — Fonction de décroissance du taux d'apprentissage. choices=[‘constant’, ‘linear’, ‘cosine’].
  • lr_decay_iters (int, par défaut None) — Nombre d'itérations pour le décroissement du taux d'apprentissage. Si None, la valeur par défaut est train_iters.
  • lr_decay_samples (int, par défaut None) — Nombre d'échantillons pour le décroissement du taux d'apprentissage. Si None, la valeur par défaut est train_samples.
  • lr_warmup_iters (int, par défaut None) — Nombre d'itérations sur lesquelles effectuer un réchauffement linéaire du taux d'apprentissage.
  • lr_warmup_samples (int, par défaut None) — Nombre d'échantillons sur lesquels effectuer un réchauffement linéaire du taux d'apprentissage.
  • lr_warmup_fraction (float, par défaut None) — Fraction des itérations/échantillons de lr-warmup sur laquelle le taux d'apprentissage est réchauffé linéairement.
  • min_lr (float, par défaut 0) — Valeur minimale du taux d'apprentissage. Le planificateur plafonne les valeurs en dessous de ce seuil.
  • consumed_samples (List, par défaut None) — Nombre d'échantillons consommés dans le même ordre que les dataloaders de l'appel à accelerator.prepare.
  • no_wd_decay_cond (Optional, par défaut None) — Condition pour désactiver le déclin du poids.
  • scale_lr_cond (Optional, par défaut None) — Condition pour mettre à l'échelle le taux d'apprentissage.
  • lr_mult (float, par défaut 1.0) — Multiplicateur du taux d'apprentissage.
  • megatron_dataset_flag (bool, par défaut False) — Indique si le format du jeu de données suit le format Indexed/Cached/MemoryMapped de Megatron-LM.
  • seq_length (int, par défaut None) — Longueur maximale de séquence à traiter.
  • encoder_seq_length (int, par défaut None) — Longueur maximale de séquence à traiter pour l'encodeur.
  • decoder_seq_length (int, par défaut None) — Longueur maximale de séquence à traiter pour le décodeur.
  • tensorboard_dir (str, par défaut None) — Chemin pour enregistrer les journaux tensorboard.
  • set_all_logging_options (bool, par défaut False) — Indique s'il faut définir toutes les options de journalisation.
  • eval_iters (int, par défaut 100) — Nombre d'itérations à exécuter pour l'évaluation de validation/test.
  • eval_interval (int, par défaut 1000) — Intervalle entre les exécutions de l'évaluation sur le jeu de validation.
  • return_logits (bool, par défaut False) — Indique s'il faut retourner les logits du modèle.
  • custom_train_step_class (Optional, par défaut None) — Classe d'étape d'entraînement personnalisée.
  • custom_train_step_kwargs (Optional, par défaut None) — Arguments personnalisés pour l'étape d'entraînement.
  • custom_model_provider_function (Optional, par défaut None) — Fonction personnalisée de fournisseur de modèle.
  • custom_prepare_model_function (Optional, par défaut None) — Fonction de préparation du modèle personnalisée.
  • custom_megatron_datasets_provider_function (Optional, par défaut None) — Fonction personnalisée de fournisseur de jeux de données d'entraînement, de validation et de test pour Megatron.
  • custom_get_batch_function (Optional, par défaut None) — Fonction de récupération de lot personnalisée.
  • custom_loss_function (Optional, par défaut None) — Fonction de perte personnalisée.
  • other_megatron_args (Optional, par défaut None) — Autres arguments de Megatron-LM. Veuillez consulter Megatron-LM.

Plugin pour Megatron-LM permettant le parallélisme de tenseurs, de pipeline, de séquences et de données. Permet également la récalculation sélective des activations et les noyaux fusionnés optimisés.

classe accelerate.utils.TorchDynamoPlugin

< >

( backend: DynamoBackend = Nonemode: str = Nonefullgraph: bool = Nonedynamic: bool = Noneoptions: Any = Nonedisable: bool = Falseuse_regional_compilation: bool = None )

Paramètres

  • backend (DynamoBackend, par défaut None) — Un backend Dynamo valide. Voir https://pytorch.org/docs/stable/torch.compiler.html pour plus de détails.
  • mode (str, par défaut None) — Les options possibles sont ‘default’, ‘reduce-overhead’ ou ‘max-autotune’.
  • fullgraph (bool, par défaut None) — Indique s'il est acceptable de diviser le modèle en plusieurs sous-graphes.
  • dynamic (bool, par défaut None) — Indique s'il faut utiliser une forme dynamique pour le traçage.
  • options (Any, par défaut None) — Un dictionnaire d'options à passer au backend.
  • disable (bool, par défaut False) — Rend torch.compile() inopérant pour les tests
  • use_regional_compilation (bool, par défaut None) — Utilisez ce paramètre pour réduire le temps de compilation à froid de torch.compile() en ciblant les blocs répétés de la même classe et en les compilant séquentiellement afin de tirer parti du cache du compilateur. Par exemple, dans GPT2LMHeadModel, le bloc/classe répété est GPT2Block, accessible via model.transformer.h[0]. Le reste du modèle (par exemple model.lm_head) est compilé séparément.

Ce plugin est utilisé pour compiler un modèle avec PyTorch 2.0

Configurations

Ce sont des classes qui peuvent être configurées et transmises à l'intégration appropriée

classe accelerate.utils.BnbQuantizationConfig

< >

( load_in_8bit: bool = Falsellm_int8_threshold: float = 6.0load_in_4bit: bool = Falsebnb_4bit_quant_type: str = 'fp4'bnb_4bit_use_double_quant: bool = Falsebnb_4bit_compute_dtype: str = 'fp16'torch_dtype: dtype = Noneskip_modules: list = Nonekeep_in_fp32_modules: list = None )

Paramètres

  • load_in_8bit (bool, par défaut False) — Active la quantification 8 bits.
  • llm_int8_threshold (float, par défaut 6.0) — Valeur du seuil de l’outliner. Ne concerne que le cas où load_in_8bit=True.
  • load_in_4bit (bool, par défaut False) — Active la quantification en 4 bits.
  • bnb_4bit_quant_type (str, par défaut fp4) — Définit le type de données de quantification dans les couches bnb.nn.Linear4Bit. Les options sont {‘fp4’,‘np4’}.
  • bnb_4bit_use_double_quant (bool, par défaut False) — Active la quantification imbriquée, où les constantes de quantification issues de la première quantification sont à nouveau quantifiées.
  • bnb_4bit_compute_dtype (bool, par défaut fp16) — Ce paramètre définit le type de calcul, qui peut différer du type d’entrée. Par exemple, les entrées peuvent être en fp32, mais le calcul peut être défini en bf16 pour gagner en vitesse. Les options sont {‘fp32’,‘fp16’,‘bf16’}.
  • torch_dtype (torch.dtype, par défaut None) — Définit le dtype des couches restantes non quantifiées. La bibliothèque bitsandbytes recommande de définir la valeur sur torch.float16 pour un modèle 8 bits et d’utiliser le même dtype que le dtype de calcul pour un modèle 4 bits.
  • skip_modules (List[str], par défaut None) — Une liste explicite des modules que nous ne quantifions pas. Le dtype de ces modules sera torch_dtype.
  • keep_in_fp32_modules (List, par défaut None) — Une liste explicite des modules que nous ne quantifions pas. Nous les conservons en torch.float32.

Un plugin pour activer la quantification 4 bits et 8 bits de BitsAndBytes

classe accelerate.DataLoaderConfiguration

< >

( split_batches: bool = Falsedispatch_batches: bool = Noneeven_batches: bool = Trueuse_seedable_sampler: bool = Falsedata_seed: int = Nonenon_blocking: bool = Falseuse_stateful_dataloader: bool = False )

Paramètres

  • split_batches (bool, par défaut False) — Indique si l'accélérateur doit diviser les lots produits par les chargeurs de données entre les appareils. Si True, la taille de lot effective utilisée sera identique pour tout type de processus distribués, mais elle doit être un multiple entier de num_processes utilisé. Si False, la taille de lot effective utilisée sera celle définie dans votre script, multipliée par le nombre de processus.
  • dispatch_batches (bool, par défaut None) — Si défini sur True, le dataloader préparé par l’Accelerator n’est parcouru que sur le processus principal, puis les lots sont divisés et diffusés à chaque processus. La valeur par défaut est True pour un DataLoader dont le jeu de données sous-jacent est un IterableDataset, et False dans le cas contraire.
  • even_batches (bool, par défaut True) — Si défini sur True, lorsque la taille totale du lot sur l’ensemble des processus ne divise pas exactement le jeu de données, les échantillons situés au début du jeu de données sont dupliqués afin que le lot puisse être réparti également entre tous les travailleurs.
  • use_seedable_sampler (bool, par défaut False) — Indique s'il faut utiliser un échantillonneur aléatoire entièrement reproductible (data_loader.SeedableRandomSampler). Garantit que les résultats d'entraînement sont entièrement reproductibles en utilisant une technique d'échantillonnage différente. Bien que les résultats puissent varier d'une graine à l'autre, les différences sont négligeables en moyenne lorsqu'on compare plusieurs graines différentes. Il convient également de l'utiliser avec set_seed() pour obtenir les meilleurs résultats.
  • data_seed (int, par défaut None) — La graine à utiliser pour le générateur sous-jacent lors de l'utilisation de use_seedable_sampler. Si None, le générateur utilisera la graine par défaut actuelle de torch.
  • non_blocking (bool, par défaut False) — Si défini sur True, le dataloader préparé par l’Accelerator utilisera des transferts hôte-vers-appareil non bloquants, permettant un meilleur chevauchement entre la communication du dataloader et le calcul. Il est recommandé que le dataloader préparé ait pin_memory défini sur True pour fonctionner correctement.
  • use_stateful_dataloader (bool, par défaut False) — Si défini sur True, le dataloader préparé par l’Accelerator sera basé sur torchdata.StatefulDataLoader. Cela nécessite l’installation de torchdata version 0.8.0 ou supérieure, qui prend en charge StatefulDataLoader.

Configuration des éléments liés au dataloader lors de l'appel de accelerator.prepare.

classe accelerate.utils.ProjectConfiguration

< >

( project_dir: str = Nonelogging_dir: str = Noneautomatic_checkpoint_naming: bool = Falsetotal_limit: int = Noneiteration: int = 0save_on_each_node: bool = False )

Paramètres

  • project_dir (str, par défaut None) — Un chemin vers un répertoire pour stocker les données.
  • logging_dir (str, par défaut None) — Un chemin vers un dossier pour stocker les journaux des enregistreurs compatibles localement. Si None, la valeur par défaut est project_dir.
  • automatic_checkpoint_naming (bool, par défaut False) — Indique si les états enregistrés doivent être nommés automatiquement de manière itérative.
  • total_limit (int, par défaut None) — Le nombre maximal d'états sauvegardés à conserver au total.
  • iteration (int, par défaut 0) — L'itération de sauvegarde actuelle.
  • save_on_each_node (bool, par défaut False) — Lors d’une formation distribuée multi-nœuds, indique s’il faut enregistrer les modèles et les points de contrôle sur chaque nœud, ou uniquement sur le nœud principal.

Configuration de l'objet Accelerator en fonction des besoins internes du projet.

set_directories

< >

( project_dir: str | None = None )

Définit self.project_dir et self.logging_dir avec les valeurs appropriées.

Variables d'environnement

Ce sont des variables d'environnement qui peuvent être activées pour différents cas d'utilisation

  • ACCELERATE_DEBUG_MODE (str) : Indique s'il faut exécuter accelerate en mode de débogage. Plus d'informations disponibles ici.

Manipulation et opérations sur les données

Celles-ci incluent des opérations sur les données qui imitent les mêmes opérations torch mais qui peuvent être utilisées sur des processus distribués.

accelerate.utils.broadcast

< >

( tensorfrom_process: int = 0 )

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à collecter.
  • from_process (int, facultatif, valeur par défaut 0) — Le processus à partir duquel envoyer les données

Diffuser récursivement un tenseur dans une liste/tuple/dictionnaire imbriquée de tenseurs vers tous les appareils.

accelerate.utils.broadcast_object_list

< >

( object_listfrom_process: int = 0 )

Paramètres

  • object_list (liste d'objets sérialisables) — La liste d'objets à diffuser. Cette liste sera modifiée en place.
  • from_process (int, facultatif, valeur par défaut 0) — Le processus à partir duquel envoyer les données.

Diffuser une liste d'objets sérialisables d'un processus vers les autres.

accelerate.utils.concatenate

< >

( datadim = 0 )

Paramètres

  • data (liste/tuple/dictionnaire imbriqué de listes de tenseurs torch.Tensor) — Les données à concaténer.
  • dim (int, facultatif, valeur par défaut 0) — La dimension sur laquelle concaténer.

Concatène récursivement les tenseurs d'une liste/tuple/dictionnaire imbriqué de listes de tenseurs de même forme. S'il n'y a qu'un seul lot de données, il est renvoyé tel quel.

accelerate.utils.convert_outputs_to_fp32

< >

( model_forward )

accelerate.utils.convert_to_fp32

< >

( tensor )

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à convertir de FP16/BF16 en FP32.

Convertit récursivement les éléments d'une liste/tuple/dictionnaire imbriqués de tenseurs en précision FP16/BF16 vers FP32.

accelerate.utils.gather

< >

( tensor )

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à collecter.

Récupérer récursivement un tenseur dans une liste/tuple/dictionnaire imbriqué de tenseurs à partir de tous les appareils.

accelerate.utils.gather_object

< >

( object: Any )

Paramètres

  • object (liste/tuple/dictionnaire imbriqué d'objets sérialisables) — Les données à collecter.

Récupérer récursivement un objet dans une liste/tuple/dictionnaire imbriqué d'objets à partir de tous les appareils.

accelerate.utils.get_grad_scaler

< >

( distributed_type: DistributedType = None**kwargs )

Paramètres

  • distributed_type (DistributedType, facultatif, valeur par défaut None) — Le type d'environnement distribué.
  • kwargs — Arguments supplémentaires pour le constructeur GradScaler utilisé.

Un utilitaire générique qui initialise la bonne implémentation de GradScaler en fonction de l’environnement et la renvoie.

accelerate.utils.get_mixed_precision_context_manager

< >

( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )

Paramètres

  • native_amp (bool, facultatif, valeur par défaut False) — Indique si la précision mixte est réellement activée.

Retourne un gestionnaire de contexte pour le mélange de précision automatique

accelerate.utils.listify

< >

( data )

Paramètres

  • data (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à convertir en nombres réguliers.

Recherche récursivement les tenseurs dans une liste/tuple/dictionnaire imbriqué et les convertit en une liste de nombres.

accelerate.utils.pad_across_processes

< >

( tensordim = 0pad_index = 0pad_first = False )

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à collecter.
  • dim (int, facultatif, valeur par défaut 0) — La dimension sur laquelle effectuer le bourrage.
  • pad_index (int, facultatif, valeur par défaut 0) — La valeur utilisée pour le bourrage.
  • pad_first (bool, facultatif, par défaut False) — Indique s'il faut ajouter des jetons de bourrage au début ou à la fin.

Rembourrer récursivement les tenseurs d'une liste/tuple/dictionnaire imbriqué de tenseurs provenant de tous les appareils à la même taille afin qu'ils puissent être regroupés en toute sécurité.

accelerate.utils.recursively_apply

< >

( funcdata*argstest_type = <function is_torch_tensor at 0x7fe7449bfed0>error_on_other_type = False**kwargs )

Paramètres

  • func (callable) — La fonction à appliquer récursivement.
  • data (liste/tuple/dictionnaire imbriqué d'objets acceptés par test_type) — Les données sur lesquelles appliquer func
  • *args — Arguments positionnels qui seront transmis à func lors de son application sur les données dépaquetées.
  • test_type (Callable[[Any], bool], facultatif, par défaut is_torch_tensor) — Le prédicat qui détermine si func doit être appliqué à un objet feuille donné.
  • error_on_other_type (bool, facultatif, par défaut False) — Indique s'il faut renvoyer une erreur ou non si, après le dépaquetage de data, on obtient un objet pour lequel test_type renvoie False. Si la valeur est False, la fonction laisse ces objets inchangés.
  • **kwargs (arguments de mots-clés supplémentaires, facultatif) — Arguments de mots-clés qui seront transmis à func lors de son application sur les données dépaquetées.

Appliquer récursivement une fonction sur une structure de données qui est une liste/tuple/dictionnaire imbriqué d'un type de base donné.

accelerate.utils.reduce

< >

( tensorreduction = 'mean'scale = 1.0 )

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à réduire.
  • reduction (str, facultatif, par défaut "mean") — Méthode de réduction. Peut être « mean », « sum », « max » ou « none ».
  • scale (float, facultatif) — Valeur de mise à l'échelle par défaut à appliquer après la réduction, uniquement valide sur XLA.

Réduire récursivement les tenseurs dans une liste/tuple/dictionnaire imbriqué de listes de tenseurs sur tous les processus par la moyenne d'une opération donnée.

accelerate.utils.send_to_device

< >

( tensordevicenon_blocking = Falseskip_keys = None )

Paramètres

  • tensor (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à envoyer vers un appareil donné.
  • device (torch.device) — L'appareil vers lequel envoyer les données.
  • non_blocking (bool, facultatif, par défaut False) — Si True, le transfert vers l'appareil est effectué de manière asynchrone, ce qui permet de superposer le déplacement des données et le calcul. N'est efficace que si l'appareil le prend en charge (par ex. CUDA).
  • skip_keys (str ou List[str], facultatif) — Une clé ou une liste de clés d'un dictionnaire tensor dont les valeurs ne doivent pas être envoyées vers le device indiqué. Les entrées portant ces clés restent sur leur appareil d'origine.

Envoie récursivement les éléments d'une liste/tuple/dictionnaire imbriqué de tenseurs vers un appareil donné.

accelerate.utils.slice_tensors

< >

( datatensor_sliceprocess_index = Nonenum_processes = None )

Paramètres

  • data (liste/tuple/dictionnaire imbriqué de torch.Tensor) — Les données à trancher.
  • tensor_slice (slice) — La tranche à extraire.

Prend récursivement une tranche dans une liste/tuple/dictionnaire imbriqué de tenseurs.

Vérifications de l'environnement

Ces fonctionnalités vérifient l'état de l'environnement de travail actuel, y compris des informations sur le système d'exploitation lui-même, ce qu'il peut prendre en charge et si des dépendances particulières sont installées.

accelerate.utils.is_bf16_available

< >

( ignore_tpu = False )

Vérifie si bf16 est pris en charge, en ignorant éventuellement le TPU

accelerate.utils.is_mps_available

< >

( min_version = '1.12' )

Vérifie si un appareil MPS est disponible. La version minimale requise est 1.12.

accelerate.utils.is_npu_available

( check_device = False )

Vérifie si torch_npu est installé et, le cas échéant, si une NPU est présente dans l'environnement

accelerate.utils.is_torch_version

< >

( operation: strversion: str )

Paramètres

  • operation (str) — Représentation sous forme de chaîne de caractères d'un opérateur, telle que ">" ou "<="
  • version (str) — Version de PyTorch sous forme de chaîne de caractères

Compare la version actuelle de PyTorch à une référence donnée à l'aide d'une opération.

accelerate.utils.is_torch_xla_available

( check_is_tpu = Falsecheck_is_gpu = False )

Vérifiez si torch_xla est disponible. Pour entraîner un job pytorch natif dans un environnement où torch xla est installé, définissez USE_TORCH_XLA sur false.

accelerate.utils.is_xpu_available

( check_device = False )

Vérifie si l'accélération XPU est disponible via PyTorch standard (>=2.7) et éventuellement si un XPU est présent dans l'environnement

Manipulation de l'environnement

accelerate.utils.patch_environment

< >

( **kwargs )

Un gestionnaire de contexte qui ajoute chaque argument par mot-clé passé à os.environ et les supprime à la sortie.

Convertira les valeurs de kwargs en chaînes de caractères et mettra toutes les clés en majuscules.

Exemple :

>>> import os
>>> from accelerate.utils import patch_environment

>>> with patch_environment(FOO="bar"):
...     print(os.environ["FOO"])  # prints "bar"
>>> print(os.environ["FOO"])  # raises KeyError

accelerate.utils.clear_environment

< >

( )

Un gestionnaire de contexte qui effacera temporairement les variables d’environnement.

Lors de la sortie de ce contexte, les variables d’environnement précédentes seront rétablies.

Exemple :

>>> import os
>>> from accelerate.utils import clear_environment

>>> os.environ["FOO"] = "bar"
>>> with clear_environment():
...     print(os.environ)
...     os.environ["FOO"] = "new_bar"
...     print(os.environ["FOO"])
{}
new_bar

>>> print(os.environ["FOO"])
bar

accelerate.commands.config.default.write_basic_config

< >

( mixed_precision = 'no'save_location: str = '/home/runner/.cache/huggingface/accelerate/default_config.yaml' )

Paramètres

  • mixed_precision (str, facultatif, par défaut “no”) — Mixed Precision à utiliser. Doit être l’un des éléments suivants : “no”, “fp16” ou “bf16”
  • save_location (str, facultatif, par défaut default_json_config_file) — Emplacement de sauvegarde personnalisé facultatif. Doit être transmis à --config_file lors de l’utilisation de accelerate launch. L’emplacement par défaut se trouve dans le dossier de cache huggingface (~/.cache/huggingface) mais peut être modifié en définissant la variable d’environnement HF_HOME, suivie de accelerate/default_config.yaml.

Crée et enregistre une configuration de cluster de base à utiliser sur une machine locale, potentiellement équipée de plusieurs GPU. Configure également le CPU s'il s'agit d'une machine ne disposant que de CPU.

Lors de la première configuration de 🤗 Accelerate, plutôt que d'exécuter accelerate config, [~utils.write_basic_config] peut être utilisé comme alternative pour une configuration rapide.

accelerate.utils.set_numa_affinity

( local_process_index: intverbose: bool | None = None )

Paramètres

  • local_process_index (int) — L'index du processus actuel sur le serveur actuel.
  • verbose (bool, facultatif) — Indique s'il faut afficher l'attribution des nouveaux cœurs CPU pour chaque processus. Si ACCELERATE_DEBUG_MODE est activé, la valeur par défaut est True.

Affecte le processus actuel à un nœud NUMA spécifique. Idéalement, c'est le plus efficace lorsqu'il y a au moins 2 CPU par nœud.

Ce résultat est mis en cache entre les appels. Si vous souhaitez le remplacer, veuillez utiliser accelerate.utils.environment.override_numa_afifnity.

accelerate.utils.environment.override_numa_affinity

< >

( local_process_index: intverbose: bool | None = None )

Paramètres

  • local_process_index (int) — L'index du processus actuel sur le serveur actuel.
  • verbose (bool, facultatif) — Indique s'il faut consigner l'attribution de chaque CPU. Si ACCELERATE_DEBUG_MODE est activé, la valeur par défaut est True.

Écrase toute affinité NUMA définie pour le processus actuel. Cette opération est très coûteuse et nécessite de recalculer l'affinité à définir ; il est préférable d'utiliser utils.environment.set_numa_affinity à la place.

accelerate.utils.purge_accelerate_environment

< >

( func_or_cls )

Décorateur permettant de nettoyer les variables d’environnement d’accelerate définies par la classe ou la fonction décorée.

Dans certaines circonstances, l’appel de certaines classes ou fonctions peut entraîner la configuration de variables d’environnement accelerate qui ne sont pas nettoyées par la suite. À titre d’exemple, lors de l’appel de :

TrainingArguments(fp16=True, …)

La variable d’environnement suivante sera définie :

ACCELERATE_MIXED_PRECISION=fp16

Cela peut affecter le code ultérieur, car la variable d’environnement prend le pas sur TrainingArguments(fp16=False). C’est particulièrement pertinent pour les tests unitaires, où nous souhaitons éviter que les tests individuels n’aient des effets de bord les uns sur les autres. Décorez la fonction de test unitaire ou la classe entière avec ce décorateur pour vous assurer qu’après chaque test, les variables d’environnement sont nettoyées. Cela fonctionne à la fois avec unittest.TestCase et les classes normales (pytest) ; cela fonctionne également lorsque vous décorez la classe parente.

Mémoire

accelerate.find_executable_batch_size

< >

( function: callable | None = Nonestarting_batch_size: int = 128reduce_batch_size_fn: callable | None = None )

Paramètres

  • function (callable, facultatif) — Une fonction à encapsuler
  • starting_batch_size (int, facultatif) — Taille de lot à essayer de faire tenir en mémoire
  • reduce_batch_size_fn (callable, facultatif) — Une fonction pour déterminer la nouvelle taille de lot après une erreur de mémoire insuffisante. Si elle n'est pas fournie, la taille de lot est multipliée par 0,9 à chaque échec. La fonction ne prend aucun argument et doit renvoyer la nouvelle taille de lot (réduite) en tant qu'int.

Un décorateur de base qui tente d’exécuter function. En cas d’échec dû à des exceptions liées à la mémoire insuffisante ou à CUDNN, la taille du lot est multipliée par 0,9 puis transmise à function

function doit prendre un paramètre batch_size comme premier argument.

Exemple :

>>> from accelerate.utils import find_executable_batch_size


>>> @find_executable_batch_size(starting_batch_size=128)
... def train(batch_size, model, optimizer):
...     ...


>>> train(model, optimizer)

Modélisation

Ces utilitaires concernent l'interaction avec les modèles PyTorch

accelerate.utils.calculate_maximum_sizes

< >

( model: Module )

Calcule la taille totale du modèle et de sa plus grande couche

accelerate.utils.compute_module_sizes

< >

( model: Moduledtype: str | torch.device | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonebuffers_only: bool = False )

Calculer la taille de chaque sous-module d'un modèle donné.

accelerate.utils.extract_model_from_parallel

< >

( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) → torch.nn.Module

Paramètres

  • model (torch.nn.Module) — Le modèle à extraire.
  • keep_fp32_wrapper (bool, facultatif) — Indique s'il faut supprimer les hooks de précision mixte du modèle.
  • keep_torch_compile (bool, facultatif) — Indique s'il faut déballer le modèle compilé.
  • recursive (bool, facultatif, par défaut False) — Indique s'il faut extraire récursivement tous les cas de module.module de model ainsi que dérouler récursivement les sous-couches enfants, et non uniquement les conteneurs distribués de premier niveau.

Retourne

torch.nn.Module

Le modèle extrait.

Extraire un modèle de ses conteneurs distribués.

accelerate.utils.get_balanced_memory

< >

( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonelow_zero: bool = False )

Paramètres

  • model (torch.nn.Module) — Le modèle à analyser.
  • max_memory (Dict, optional) — A dictionary device identifier to maximum memory. Will default to the maximum memory available if unset. Example: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], facultatif) — Une liste de noms de classes de couches qui ne doivent jamais être réparties sur plusieurs appareils (par exemple, toute couche disposant d'une connexion résiduelle).
  • dtype (str ou torch.dtype, facultatif) — Si fourni, les poids seront convertis en ce type lors du chargement.
  • special_dtypes (Dict[str, Union[str, torch.device]], facultatif) — Si fourni, dtypes spéciaux à prendre en compte pour certains poids spécifiques (remplace le dtype utilisé par défaut pour tous les poids).
  • low_zero (bool, facultatif) — Minimise le nombre de poids sur le GPU 0, ce qui est pratique lorsqu’il est utilisé pour d’autres opérations (comme la fonction generate de Transformers).

Calculer un dictionnaire max_memory pour infer_auto_device_map() afin d'équilibrer l'utilisation de chaque GPU disponible.

Tous les calculs sont effectués en analysant les tailles et les dtypes des paramètres du modèle. En conséquence, le modèle peut se trouver sur le meta device (comme ce serait le cas s'il était initialisé dans le gestionnaire de contexte init_empty_weights).

accelerate.utils.get_max_layer_size

< >

( modules: listmodule_sizes: dictno_split_module_classes: list ) → Tuple[int, List[str]]

Paramètres

  • modules (List[Tuple[str, torch.nn.Module]]) — La liste des modules nommés pour lesquels nous souhaitons déterminer la taille maximale des couches.
  • module_sizes (Dict[str, int]) — Un dictionnaire associant chaque nom de couche à sa taille (tel que généré par compute_module_sizes).
  • no_split_module_classes (List[str]) — Une liste de noms de classes pour les couches que nous ne voulons pas diviser.

Retourne

Tuple[int, List[str]]

La taille maximale d'une couche, accompagnée de la liste des noms de couches atteignant cette taille maximale.

Fonction utilitaire qui parcourt une liste de modules nommés et renvoie la taille maximale utilisée par une couche complète. La définition d'une couche est la suivante :

  • un module sans enfants directs (uniquement des paramètres et des tampons)
  • un module dont le nom de classe figure dans la liste no_split_module_classes

accelerate.infer_auto_device_map

< >

( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.dtype] | None = Noneverbose: bool = Falseclean_result: bool = Trueoffload_buffers: bool = Falsefallback_allocation: bool = False )

Paramètres

  • model (torch.nn.Module) — Le modèle à analyser.
  • max_memory (Dict, optional) — A dictionary device identifier to maximum memory. Will default to the maximum memory available if unset. Example: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], facultatif) — Une liste de noms de classes de couches qui ne doivent jamais être réparties sur plusieurs appareils (par exemple, toute couche disposant d'une connexion résiduelle).
  • dtype (str ou torch.dtype, facultatif) — Si fourni, les poids seront convertis en ce type lors du chargement.
  • special_dtypes (Dict[str, Union[str, torch.device]], facultatif) — Si fourni, dtypes spéciaux à prendre en compte pour certains poids spécifiques (remplace le dtype utilisé par défaut pour tous les poids).
  • verbose (bool, facultatif, par défaut False) — Indique s'il faut fournir des déclarations de débogage lorsque la fonction construit le device_map.
  • clean_result (bool, facultatif, par défaut True) — Nettoyer le device_map résultant en regroupant tous les sous-modules qui sont placés sur le même appareil.
  • offload_buffers (bool, facultatif, par défaut False) — Dans les couches déchargées sur le CPU ou le disque dur, indique s'il faut également décharger les buffers en plus des paramètres.
  • fallback_allocation (bool, facultatif, valeur par défaut False) — Lorsque l'allocation régulière échoue, tente d'allouer un module qui respecte la limite de taille en utilisant un parcours en largeur (BFS).

Calculer une carte de périphériques pour un modèle donné en accordant la priorité aux GPU, puis en déchargeant sur le CPU et enfin sur le disque, de sorte que :

  • nous ne dépassons pas la mémoire disponible sur aucun des GPU.
  • si un offload vers le CPU est nécessaire, il reste toujours de la place sur le GPU 0 pour remettre la couche offloadée sur le CPU qui a la plus grande taille.
  • si un offload vers le CPU est nécessaire, nous ne dépassons pas la RAM disponible sur le CPU.
  • si l'offload sur le disque est nécessaire, il reste toujours de la place sur le CPU pour remettre la couche offloadée sur disque qui a la plus grande taille.

Tous les calculs sont effectués en analysant les tailles et les dtypes des paramètres du modèle. En conséquence, le modèle peut se trouver sur le meta device (comme ce serait le cas s'il était initialisé dans le gestionnaire de contexte init_empty_weights).

accelerate.load_checkpoint_in_model

< >

( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )

Paramètres

  • model (torch.nn.Module) — Le modèle dans lequel nous souhaitons charger un point de contrôle.
  • checkpoint (str ou os.PathLike) — Le dossier de checkpoint à charger. Il peut s'agir de :
    • un chemin vers un fichier contenant un état de modèle complet
    • un chemin vers un fichier .json contenant l'index d'un point de contrôle fragmenté
    • un chemin vers un dossier contenant un fichier .index.json unique et les fragments d'un point de contrôle.
    • un chemin vers un dossier contenant un fichier pytorch_model.bin ou model.safetensors unique.
  • device_map (Dict[str, Union[int, str, torch.device]], facultatif) — Une carte qui spécifie l’emplacement de chaque sous-module. Elle n’a pas besoin d’être affinée au niveau de chaque nom de paramètre/buffer : dès qu’un nom de module est inclus, tous ses sous-modules seront envoyés sur le même appareil.
  • offload_folder (str ou os.PathLike, facultatif) — Si la device_map contient la valeur "disk", le dossier où les poids seront déchargés.
  • dtype (str ou torch.dtype, facultatif) — Si fourni, les poids seront convertis en ce type lors du chargement.
  • offload_state_dict (bool, facultatif, valeur par défaut False) — Si True, déplace temporairement le dictionnaire d’état CPU sur le disque dur pour éviter un épuisement de la RAM CPU si le poids du dictionnaire d’état CPU + le plus grand fragment ne tient pas.
  • offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut inclure les tampons (buffers) dans les poids déchargés sur le disque.
  • keep_in_fp32_modules(List[str], facultatif) — Une liste des modules que nous conservons en type de données torch.float32.
  • offload_8bit_bnb (bool, facultatif) — Indique s'il faut activer ou non le déchargement des modules 8 bits sur le CPU/le disque.
  • strict (bool, facultatif, par défaut False) — Indique s'il faut imposer strictement que les clés du state_dict du checkpoint correspondent aux clés du state_dict du modèle.
  • full_state_dict (bool, facultatif, valeur par défaut True) — si cette valeur est définie sur True, tous les tenseurs du state_dict chargé seront regroupés. Aucun ShardedTensor ni DTensor ne sera présent dans le state_dict chargé.
  • broadcast_from_rank0 (False, facultatif, valeur par défaut False) — lorsque l’option est True, un groupe de processus distribué ProcessGroup doit être initialisé. Le rank0 doit recevoir un state_dict complet et diffusera les tenseurs du state_dict un par un aux autres ranks. Les autres ranks recevront les tenseurs et les fractionneront (le cas échéant) en fonction des shards locaux du modèle.

Charge un point de contrôle (éventuellement fragmenté) à l'intérieur d'un modèle, en envoyant éventuellement les poids vers un appareil donné au fur et à mesure de leur chargement.

Une fois chargé sur les différents appareils, vous devez toujours appeler dispatch_model() sur votre modèle pour le rendre exécutable. Pour regrouper le chargement du point de contrôle et la distribution en un seul appel, utilisez load_checkpoint_and_dispatch().

accelerate.utils.load_offloaded_weights

< >

( modelindexoffload_folder )

Paramètres

  • model (torch.nn.Module) — Le modèle dans lequel charger les poids.
  • index (dict) — Un dictionnaire contenant le nom du paramètre et ses métadonnées pour chaque paramètre qui a été déchargé du modèle.
  • offload_folder (str) — Le dossier où les poids déchargés sont stockés.

Charge les poids depuis le dossier de déchargement dans le modèle.

accelerate.utils.load_state_dict

< >

( checkpoint_filedevice_map = None )

Paramètres

  • checkpoint_file (str) — Le chemin du point de contrôle à charger.
  • device_map (Dict[str, Union[int, str, torch.device]], facultatif) — Une carte qui spécifie l’emplacement de chaque sous-module. Elle n’a pas besoin d’être affinée au niveau de chaque nom de paramètre/buffer : dès qu’un nom de module est inclus, tous ses sous-modules seront envoyés sur le même appareil.

Charge un point de contrôle à partir d'un fichier donné. Si le point de contrôle est au format safetensors et qu'une carte de périphériques est transmise, les poids peuvent être chargés rapidement directement sur le GPU.

accelerate.utils.offload_state_dict

< >

( save_dir: str | os.PathLikestate_dict: dict )

Paramètres

  • save_dir (str ou os.PathLike) — Le répertoire dans lequel décharger le dictionnaire d'état.
  • state_dict (Dict[str, torch.Tensor]) — Le dictionnaire de tenseurs à décharger.

Décharger un état de dictionnaire dans un dossier donné.

accelerate.utils.retie_parameters

< >

( modeltied_params )

Paramètres

  • model (torch.nn.Module) — Le modèle dans lequel relier les paramètres.
  • tied_params (List[List[str]]) — Paramètre de correspondance entre le nom d'un paramètre et le nom du paramètre lié, tel que obtenu par find_tied_parameters.

Retie les paramètres liés dans un modèle donné si le lien a été rompu (par exemple lors de l’ajout de hooks).

accelerate.utils.set_module_tensor_to_device

< >

( module: Moduletensor_name: strdevice: int | str | torch.devicevalue: torch.Tensor | None = Nonedtype: str | torch.dtype | None = Nonefp16_statistics: torch.HalfTensor | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = Nonenon_blocking: bool = Falseclear_cache: bool = True )

Paramètres

  • module (torch.nn.Module) — Le module dans lequel se trouve le tenseur que nous souhaitons déplacer.
  • tensor_name (str) — Le nom complet du paramètre/buffer.
  • device (int, str ou torch.device) — L'appareil sur lequel définir le tenseur.
  • value (torch.Tensor, facultatif) — La valeur du tenseur (utile lors du passage de l’appareil meta à tout autre appareil).
  • dtype (torch.dtype, facultatif) — Si une valeur est transmise, la valeur du paramètre sera convertie en ce dtype. Sinon, value sera convertie en le dtype du paramètre existant dans le modèle.
  • fp16_statistics (torch.HalfTensor, facultatif) — La liste des statistiques fp16 à définir sur le module, utilisée pour la sérialisation de modèles 8 bits.
  • tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], facultatif, par défaut None) — Une correspondance entre les pointeurs de données actuels et des dictionnaires d’appareils vers les poids liés déjà distribués. Pour un appareil d’exécution donné, ce paramètre est utile pour réutiliser le premier pointeur disponible d’un poids partagé sur l’appareil pour tous les autres, au lieu de dupliquer la mémoire.
  • non_blocking (bool, facultatif, par défaut False) — Si True, le transfert vers le périphérique sera asynchrone par rapport à l'hôte, si possible.
  • clear_cache (bool, facultatif, par défaut True) — Indique s'il faut ou non vider le cache de l'appareil après avoir placé le tenseur sur l'appareil.

Une fonction utilitaire pour placer un tenseur donné (paramètre ou buffer) d'un module sur un appareil spécifique (notez que faire param.to(device) crée un nouveau tenseur non lié au paramètre, d'où la nécessité de cette fonction).

accelerate.utils.get_module_children_bottom_up

< >

( model: Modulereturn_fqns: bool = False ) → list[torch.nn.Module]

Paramètres

  • model (torch.nn.Module) — le modèle dont on veut obtenir les enfants

Retourne

list[torch.nn.Module]

une liste des modules enfants de model dans l'ordre de bas en haut. Le dernier élément est le model lui-même.

Parcourez le modèle dans l'ordre de bas en haut et retournez les modules enfants dans cet ordre.

Parallèle

Celles-ci incluent des utilitaires généraux qui doivent être utilisés lors du travail en parallèle.

accelerate.utils.extract_model_from_parallel

< >

( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) → torch.nn.Module

Paramètres

  • model (torch.nn.Module) — Le modèle à extraire.
  • keep_fp32_wrapper (bool, facultatif) — Indique s'il faut supprimer les hooks de précision mixte du modèle.
  • keep_torch_compile (bool, facultatif) — Indique s'il faut déballer le modèle compilé.
  • recursive (bool, facultatif, par défaut False) — Indique s'il faut extraire récursivement tous les cas de module.module de model ainsi que dérouler récursivement les sous-couches enfants, et non uniquement les conteneurs distribués de premier niveau.

Retourne

torch.nn.Module

Le modèle extrait.

Extraire un modèle de ses conteneurs distribués.

accelerate.utils.save

< >

( objfsave_on_each_node: bool = Falsesafe_serialization: bool = False )

Paramètres

  • obj — Les données à enregistrer
  • f — Le fichier (ou objet semblable à un fichier) à utiliser pour enregistrer les données
  • save_on_each_node (bool, facultatif, valeur par défaut False) — Indique s'il faut enregistrer uniquement sur le processus principal global
  • safe_serialization (bool, facultatif, valeur par défaut False) — Indique s'il faut enregistrer obj en utilisant safetensors ou la méthode traditionnelle de PyTorch (qui utilise pickle).

Enregistrez les données sur le disque. Utilisez à la place de torch.save().

accelerate.utils.load

< >

( fmap_location = None**kwargs )

Paramètres

  • f — Le fichier (ou objet semblable à un fichier) à utiliser pour charger les données
  • map_location — une fonction, torch.device, une chaîne de caractères ou un dictionnaire spécifiant comment remapper les emplacements de stockage
  • **kwargs — Arguments supplémentaires à passer à torch.load().

Remplacement compatible en tant que tel de torch.load() qui permet d'utiliser weights_only si la version de torch est 2.4.0 ou supérieure. Sinon, l'argument est ignoré.

Ajoutera également (puis retirera) une exception pour les tableaux numpy

accelerate.utils.wait_for_everyone

< >

( )

Introduit un point de synchronisation dans le script, garantissant que tous les processus ont atteint ce point avant de continuer.

Assurez-vous que tous les processus atteindront cette instruction, sinon l'un de vos processus restera bloqué indéfiniment.

Aléatoire

Ces utilitaires concernent la configuration et la synchronisation de tous les états aléatoires.

accelerate.utils.set_seed

< >

( seed: intdevice_specific: bool = Falsedeterministic: bool = False )

Paramètres

  • seed (int) — La graine à définir.
  • device_specific (bool, facultatif, par défaut False) — Indique s'il faut faire varier légèrement la graine sur chaque appareil à l'aide de self.process_index.
  • deterministic (bool, facultatif, par défaut False) — Indique s'il faut utiliser des algorithmes déterministes lorsque ceux-ci sont disponibles. Peut ralentir l'entraînement.

Fonction utilitaire pour un comportement reproductible afin de définir la graine dans random, numpy, torch.

accelerate.utils.synchronize_rng_state

< >

( rng_type: accelerate.utils.dataclasses.RNGType | None = Nonegenerator: torch.Generator | None = None )

accelerate.synchronize_rng_states

< >

( rng_types: listgenerator: torch.Generator | None = None )

PyTorch XLA

Ces utilitaires sont utiles lors de l'utilisation de PyTorch avec XLA.

accelerate.utils.install_xla

< >

( upgrade: bool = False )

Paramètres

  • upgrade (bool, facultatif, par défaut False) — Indique s'il faut mettre à niveau torch et installer les dernières roues torch_xla.

Fonction utilitaire pour installer les roues xla appropriées en fonction de la version de torch dans Google Colaboratory.

Exemple :

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

Chargement des poids du modèle

Celles-ci incluent des utilitaires utiles pour charger des points de contrôle.

accelerate.load_checkpoint_in_model

< >

( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )

Paramètres

  • model (torch.nn.Module) — Le modèle dans lequel nous souhaitons charger un point de contrôle.
  • checkpoint (str ou os.PathLike) — Le dossier de checkpoint à charger. Il peut s'agir de :
    • un chemin vers un fichier contenant un état de modèle complet
    • un chemin vers un fichier .json contenant l'index d'un point de contrôle fragmenté
    • un chemin vers un dossier contenant un fichier .index.json unique et les fragments d'un point de contrôle.
    • un chemin vers un dossier contenant un fichier pytorch_model.bin ou model.safetensors unique.
  • device_map (Dict[str, Union[int, str, torch.device]], facultatif) — Une carte qui spécifie l’emplacement de chaque sous-module. Elle n’a pas besoin d’être affinée au niveau de chaque nom de paramètre/buffer : dès qu’un nom de module est inclus, tous ses sous-modules seront envoyés sur le même appareil.
  • offload_folder (str ou os.PathLike, facultatif) — Si la device_map contient la valeur "disk", le dossier où les poids seront déchargés.
  • dtype (str ou torch.dtype, facultatif) — Si fourni, les poids seront convertis en ce type lors du chargement.
  • offload_state_dict (bool, facultatif, valeur par défaut False) — Si True, déplace temporairement le dictionnaire d’état CPU sur le disque dur pour éviter un épuisement de la RAM CPU si le poids du dictionnaire d’état CPU + le plus grand fragment ne tient pas.
  • offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut inclure les tampons (buffers) dans les poids déchargés sur le disque.
  • keep_in_fp32_modules(List[str], facultatif) — Une liste des modules que nous conservons en type de données torch.float32.
  • offload_8bit_bnb (bool, facultatif) — Indique s'il faut activer ou non le déchargement des modules 8 bits sur le CPU/le disque.
  • strict (bool, facultatif, par défaut False) — Indique s'il faut imposer strictement que les clés du state_dict du checkpoint correspondent aux clés du state_dict du modèle.
  • full_state_dict (bool, facultatif, valeur par défaut True) — si cette valeur est définie sur True, tous les tenseurs du state_dict chargé seront regroupés. Aucun ShardedTensor ni DTensor ne sera présent dans le state_dict chargé.
  • broadcast_from_rank0 (False, facultatif, valeur par défaut False) — lorsque l’option est True, un groupe de processus distribué ProcessGroup doit être initialisé. Le rank0 doit recevoir un state_dict complet et diffusera les tenseurs du state_dict un par un aux autres ranks. Les autres ranks recevront les tenseurs et les fractionneront (le cas échéant) en fonction des shards locaux du modèle.

Charge un point de contrôle (éventuellement fragmenté) à l'intérieur d'un modèle, en envoyant éventuellement les poids vers un appareil donné au fur et à mesure de leur chargement.

Une fois chargé sur les différents appareils, vous devez toujours appeler dispatch_model() sur votre modèle pour le rendre exécutable. Pour regrouper le chargement du point de contrôle et la distribution en un seul appel, utilisez load_checkpoint_and_dispatch().

Quantification

Celles-ci incluent des utilitaires utiles pour quantiser un modèle.

accelerate.utils.load_and_quantize_model

< >

( model: Modulebnb_quantization_config: BnbQuantizationConfigweights_location: str | os.PathLike | None = Nonedevice_map: dict[str, int | str | torch.device] | None = Noneno_split_module_classes: list[str] | None = Nonemax_memory: dict[int | str, int | str] | None = Noneoffload_folder: str | os.PathLike | None = Noneoffload_state_dict: bool = False ) → torch.nn.Module

Paramètres

  • model (torch.nn.Module) — Modèle d’entrée. Le modèle peut être déjà chargé ou sur le méta-appareil
  • bnb_quantization_config (BnbQuantizationConfig) — Les paramètres de quantification bitsandbytes
  • weights_location (str ou os.PathLike) — Le dossier weights_location à charger. Il peut s'agir de :
    • un chemin vers un fichier contenant un état de modèle complet
    • un chemin vers un fichier .json contenant l'index d'un point de contrôle fragmenté
    • un chemin vers un dossier contenant un fichier .index.json unique et les fragments d'un point de contrôle.
    • un chemin vers un dossier contenant un fichier pytorch_model.bin unique.
  • device_map (Dict[str, Union[int, str, torch.device]], facultatif) — Une carte qui spécifie l’emplacement de chaque sous-module. Elle n’a pas besoin d’être affinée au niveau de chaque nom de paramètre/buffer : dès qu’un nom de module est inclus, tous ses sous-modules seront envoyés sur le même appareil.
  • no_split_module_classes (List[str], facultatif) — Une liste de noms de classes de couches qui ne doivent jamais être réparties sur plusieurs appareils (par exemple, toute couche disposant d'une connexion résiduelle).
  • max_memory (Dict, facultatif) — Un dictionnaire associant un identifiant de périphérique à la mémoire maximale. Par défaut, la valeur est la mémoire maximale disponible si non définie.
  • offload_folder (str ou os.PathLike, facultatif) — Si la device_map contient la valeur "disk", le dossier où les poids seront déchargés.
  • offload_state_dict (bool, facultatif, valeur par défaut False) — Si True, déplace temporairement le dictionnaire d’état CPU sur le disque dur pour éviter un épuisement de la RAM CPU si le poids du dictionnaire d’état CPU + le plus grand fragment ne tient pas.

Retourne

torch.nn.Module

Le modèle quantifié

Cette fonction quantise le modèle d'entrée avec la configuration associée transmise dans bnb_quantization_config. Si le modèle est sur le périphérique meta, nous chargerons et répartirons les poids selon la device_map transmise. Si le modèle est déjà chargé, nous quantiserons le modèle et le placerons sur le GPU,

Update on GitHub

←FP8 Utilitaires Megatron-LM→