Accelerate documentation

Travailler avec de grands modèles

Accelerate

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).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Travailler avec de grands modèles

Dispatch et offload

init_empty_weights

accelerate.init_empty_weights

< source >

( include_buffers: bool | None = None )

Paramètres

include_buffers (bool, facultatif) — Indique s'il faut également placer tous les tampons sur l'appareil méta lors de l'initialisation.

Un gestionnaire de contexte sous lequel les modèles sont initialisés avec tous les paramètres sur le périphérique meta, créant ainsi un modèle vide. Utile lorsque l’initialisation seule du modèle épuiserait la RAM disponible.

Exemple :

import torch.nn as nn
from accelerate import init_empty_weights

# Initialize a model with 100 billions parameters in no time and without using any RAM.
with init_empty_weights():
    tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])

Tout modèle créé sous ce gestionnaire de contexte ne possède aucun poids. Par conséquent, vous ne pouvez pas effectuer une opération telle que model.to(some_device) avec celui-ci. Pour charger les poids dans votre modèle vide, consultez load_checkpoint_and_dispatch(). Assurez-vous d’écraser le paramètre device_map par défaut de load_checkpoint_and_dispatch(), sinon la dispatch n’est pas appelée.

cpu_offload

accelerate.cpu_offload

< source >

( model: Moduleexecution_device: torch.device | None = Noneoffload_buffers: bool = Falsestate_dict: dict[str, torch.Tensor] | None = Nonepreload_module_classes: list[str] | None = None )

Paramètres

model (torch.nn.Module) — Le modèle à décharger.
execution_device (torch.device, facultatif) — L’appareil sur lequel la passe avant du modèle sera exécutée (doit être un GPU). Par défaut, l’appareil du premier paramètre du modèle est utilisé.
offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut décharger les tampons avec les paramètres du modèle.
state_dict (Dict[str, torch.Tensor], facultatif) — Le state dict du modèle qui sera conservé sur le CPU.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.

Active le déchargement complet sur CPU pour un modèle. En conséquence, tous les paramètres du modèle seront déchargés et une seule copie du dictionnaire d'état du modèle sera conservée. Lors du passage avant, les paramètres seront extraits de ce dictionnaire d'état et placés sur l'appareil d'exécution transmis au fur et à mesure qu'ils sont nécessaires, puis déchargés à nouveau.

cpu_offload_with_hook

accelerate.cpu_offload_with_hook

< source >

( model: Moduleexecution_device: int | str | torch.device | None = Noneprev_module_hook: accelerate.hooks.UserCpuOffloadHook | None = None )

Paramètres

model (torch.nn.Module) — Le modèle à décharger.
execution_device(str, int ou torch.device, facultatif) — L’appareil sur lequel le modèle doit être exécuté. Par défaut, l’appareil MPS est utilisé s’il est disponible, puis l’appareil 0 s’il existe un appareil accélérateur, et enfin le CPU.
prev_module_hook (UserCpuOffloadHook, facultatif) — Le hook renvoyé par cette fonction pour un modèle précédent du pipeline que vous exécutez. S’il est transmis, sa méthode de déchargement sera appelée juste avant le forward du modèle auquel ce hook est attaché.

Décharge un modèle sur le CPU et le remet sur un périphérique d'exécution lors de son exécution. La différence avec cpu_offload() est que le modèle reste sur le périphérique d'exécution après le forward et n'est déchargé à nouveau que lorsque la méthode offload du hook retourné est appelée. Utile pour les pipelines exécutant un modèle dans une boucle.

Exemple :

model_1, hook_1 = cpu_offload_with_hook(model_1, device)
model_2, hook_2 = cpu_offload_with_hook(model_2, device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, device, prev_module_hook=hook_2)

hid_1 = model_1(input)
for i in range(50):
    # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
    hid_2 = model_2(hid_1)
# model2 is offloaded to the CPU just before this forward.
hid_3 = model_3(hid_3)

# For model3, you need to manually call the hook offload method.
hook_3.offload()

disk_offload

accelerate.disk_offload

< source >

( model: Moduleoffload_dir: str | os.PathLikeexecution_device: torch.device | None = Noneoffload_buffers: bool = Falsepreload_module_classes: list[str] | None = None )

Paramètres

model (torch.nn.Module) — Le modèle à décharger.
offload_dir (str ou os.PathLike) — Le dossier dans lequel décharger les poids du modèle (ou où les poids du modèle sont déjà déchargés).
execution_device (torch.device, facultatif) — L’appareil sur lequel la passe avant du modèle sera exécutée (doit être un GPU). Par défaut, l’appareil du premier paramètre du modèle est utilisé.
offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut décharger les tampons avec les paramètres du modèle.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.

Active le déchargement complet sur disque pour un modèle. En conséquence, tous les paramètres du modèle seront déchargés en tant que tableaux mappés en mémoire dans un dossier donné. Lors du passage avant, les paramètres seront accédés depuis ce dossier et placés sur l’appareil d’exécution transmis au fur et à mesure qu’ils sont nécessaires, puis à nouveau déchargés.

dispatch_model

accelerate.dispatch_model

< source >

Paramètres

model (torch.nn.Module) — Le modèle à dispatcher.
device_map (Dict[str, Union[str, int, torch.device]]) — Un dictionnaire associant les noms de modules dans le state_dict des modèles à l’appareil sur lequel ils doivent être placés. Notez que "disk" est accepté, même s’il ne s’agit pas d’une valeur valide pour torch.device.
main_device (str, int ou torch.device, facultatif) — Le principal appareil d’exécution. Par défaut, il s’agit du premier appareil de la device_map différent de "cpu" ou "disk".
state_dict (Dict[str, torch.Tensor], facultatif) — Le state dict de la partie du modèle qui sera conservée sur CPU.
offload_dir (str ou os.PathLike) — Le dossier dans lequel décharger les poids du modèle (ou où les poids du modèle sont déjà déchargés).
offload_index (Dict, facultatif) — Un dictionnaire associant le nom de chaque poids à ses informations (dtype/ shape ou nom de fichier safetensors). Par défaut, il correspond à l’index enregistré dans save_folder.
offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut décharger les tampons avec les paramètres du modèle.
skip_keys (str ou List[str], facultatif) — Une liste de clés à ignorer lors du déplacement des entrées ou des sorties entre les appareils.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.
force_hooks (bool, facultatif, valeur par défaut False) — Indique s'il faut forcer l'attachement des hooks de périphérique au modèle, même si toutes les couches sont réparties sur un seul périphérique.

Distribue un modèle selon une carte de périphériques donnée. Les couches du modèle peuvent être réparties sur plusieurs GPU, déchargées sur le CPU ou même sur le disque.

load_checkpoint_and_dispatch

accelerate.load_checkpoint_and_dispatch

< source >

Paramètres

model (torch.nn.Module) — Le modèle dans lequel nous voulons 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.
device_map (Dict[str, Union[int, str, torch.device]], facultatif) — Une carte qui spécifie où chaque sous-module doit être placé. Il n'est pas nécessaire de la préciser pour 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.
Pour que Accelerate calcule automatiquement le device_map le plus optimisé, définissez device_map="auto". Pour plus d'informations sur chaque option, voir ici. La valeur par défaut est None, ce qui signifie que dispatch_model() ne sera pas appelé.
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 pour chaque GPU et la RAM CPU disponible si non définie.
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).
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_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.
dtype (str ou torch.dtype, facultatif) — Si fourni, les poids seront convertis en ce type lors du chargement.
offload_state_dict (bool, facultatif) — Si True, décharge temporairement le state dict CPU sur le disque dur pour éviter d’épuiser la RAM CPU si le poids du state dict CPU + le plus grand shard ne tient pas. La valeur par défaut est True si la carte de dispositifs choisie contient des valeurs "disk".
skip_keys (str ou List[str], facultatif) — Une liste de clés à ignorer lors du déplacement des entrées ou des sorties entre les appareils.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.
force_hooks (bool, facultatif, valeur par défaut False) — Indique s'il faut forcer l'attachement des hooks de périphérique au modèle, même si toutes les couches sont réparties sur un seul périphérique.
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 fractionné) à l’intérieur d’un modèle, en envoyant éventuellement les poids vers un appareil donné au fur et à mesure de leur chargement, et ajoute les différents hooks qui permettront à ce modèle de fonctionner correctement (même s’il est réparti sur plusieurs appareils).

Exemple :

>>> from accelerate import init_empty_weights, load_checkpoint_and_dispatch
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoConfig, AutoModelForCausalLM

>>> # Download the Weights
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> weights_location = hf_hub_download(checkpoint, "pytorch_model.bin")

>>> # Create a model and initialize it with empty weights
>>> config = AutoConfig.from_pretrained(checkpoint)
>>> with init_empty_weights():
...     model = AutoModelForCausalLM.from_config(config)

>>> # Load the checkpoint and dispatch it to the right devices
>>> model = load_checkpoint_and_dispatch(
...     model, weights_location, device_map="auto", no_split_module_classes=["GPTJBlock"]
... )

load_checkpoint_in_model

accelerate.load_checkpoint_in_model

< source >

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().

infer_auto_device_map

accelerate.infer_auto_device_map

< source >

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).

Hooks

ModelHook

classe accelerate.hooks.ModelHook

< source >

( )

Un hook contenant des callbacks à exécuter juste avant et après la méthode forward d'un modèle. La différence avec les hooks existants de PyTorch est qu'ils reçoivent les kwargs.

Attribut de classe :

no_grad (bool, facultatif, par défaut False) — Indique s'il faut exécuter le passage avant réel sous le gestionnaire de contexte torch.no_grad().

detach_hook

< source >

( module )

Paramètres

module (torch.nn.Module) — Le module détaché de cet hook.

À exécuter lorsque l'accroche est détachée d'un module.

init_hook

< source >

( module )

Paramètres

module (torch.nn.Module) — Le module attaché à cet hook.

À exécuter lorsque l'accroche est attachée au module.

post_forward

< source >

( moduleoutput ) → Any

Paramètres

module (torch.nn.Module) — Le module dont le passage avant a été exécuté juste avant cet événement.
output (Any) — La sortie du module.

Retourne

Any

La sortie output traitée.

À exécuter juste après la méthode forward du modèle.

pre_forward

< source >

( module*args**kwargs ) → Tuple[Tuple[Any], Dict[Str, Any]]

Paramètres

module (torch.nn.Module) — Le module dont le passage avant (forward pass) sera exécuté juste après cet événement.
args (Tuple[Any]) — Les arguments positionnels passés au module.
kwargs (Dict[Str, Any]) — Les arguments par mot-clé passés au module.

Retourne

Tuple[Tuple[Any], Dict[Str, Any]]

Un tuple contenant les args et kwargs traités.

À exécuter juste avant la méthode forward du modèle.

AlignDevicesHook

classe accelerate.hooks.AlignDevicesHook

< source >

Paramètres

execution_device (torch.device, facultatif) — L’appareil sur lequel les entrées et les poids du modèle doivent être placés avant le passage avant.
offload (bool, facultatif, par défaut False) — Indique si les poids doivent être déchargés après le passage avant.
io_same_device (bool, facultatif, par défaut False) — Indique si la sortie doit être placée sur le même appareil que l'entrée.
weights_map (Mapping[str, torch.Tensor], facultatif) — Lorsque les poids du modèle sont déchargés, une carte (éventuellement paresseuse) des noms de paramètres vers les valeurs des tenseurs.
offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut inclure les buffers du module associé lors de l'offloading.
place_submodules (bool, facultatif, valeur par défaut False) — Indique s'il faut placer les sous-modules sur execution_device lors de l'événement init_hook.

Un ModelHook générique qui garantit que les entrées et les poids du modèle sont sur le même appareil pour le passage avant du module associé, avec un éventuel déchargement des poids après le passage avant.

SequentialHook

classe accelerate.hooks.SequentialHook

< source >

( *hooks )

Un hook pouvant contenir plusieurs hooks et les parcourant à chaque événement.

LayerwiseCastingHook

classe accelerate.hooks.LayerwiseCastingHook

< source >

( storage_dtype: dtypecompute_dtype: dtypenon_blocking: bool )

Un hook qui convertit les poids d'un module en un type de données de haute précision pour le calcul, et en un type de données de basse précision pour le stockage. Ce processus peut entraîner une perte de qualité dans la sortie, mais peut réduire considérablement l'empreinte mémoire.

Ajout de hooks

add_hook_to_module

accelerate.hooks.add_hook_to_module

< source >

( module: Modulehook: ModelHookappend: bool = False ) → torch.nn.Module

Paramètres

module (torch.nn.Module) — Le module auquel attacher un hook.
hook (ModelHook) — Le hook à attacher.
append (bool, facultatif, valeur par défaut False) — Indique si le hook doit être enchaîné avec un hook existant (si le module en contient déjà un) ou non.

Retourne

torch.nn.Module

Le même module, avec le hook attaché (le module est modifié en place, donc le résultat peut être ignoré).

Ajoute un hook à un module donné. Cette opération réécrit la méthode forward du module pour y inclure le hook. Pour supprimer ce comportement et restaurer la méthode forward d’origine, utilisez remove_hook_from_module.

Si le module contient déjà un hook, celui-ci sera remplacé par le nouveau hook passé par défaut. Pour enchaîner deux hooks, passez append=True, ce qui enchaîne le hook actuel et le nouveau hook dans une instance de la classe SequentialHook.

attach_execution_device_hook

accelerate.hooks.attach_execution_device_hook

< source >

Paramètres

module (torch.nn.Module) — Le module auquel nous souhaitons attacher les hooks.
execution_device (int, str ou torch.device) — L'appareil sur lequel les entrées et les poids du modèle doivent être placés avant le passage avant.
skip_keys (str ou List[str], facultatif) — Une liste de clés à ignorer lors du déplacement des entrées ou des sorties entre les appareils.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.
tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], facultatif, par défaut None) — Une correspondance entre les pointeurs de données 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é pour tous les autres, au lieu de dupliquer la mémoire.

Attache récursivement AlignDevicesHook à tous les sous-modules d'un modèle donné afin de s'assurer qu'ils disposent du bon appareil d'exécution

attach_align_device_hook

accelerate.hooks.attach_align_device_hook

< source >

( module: Moduleexecution_device: torch.device | None = Noneoffload: bool = Falseweights_map: collections.abc.Mapping | None = Noneoffload_buffers: bool = Falsemodule_name: str = ''skip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None )

Paramètres

module (torch.nn.Module) — Le module auquel nous souhaitons attacher les hooks.
execution_device (torch.device, facultatif) — L’appareil sur lequel les entrées et les poids du modèle doivent être placés avant le passage avant.
offload (bool, facultatif, par défaut False) — Indique si les poids doivent être déchargés après le passage avant.
weights_map (Mapping[str, torch.Tensor], facultatif) — Lorsque les poids du modèle sont déchargés, une carte (éventuellement paresseuse) des noms de paramètres vers les valeurs des tenseurs.
offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut inclure les buffers du module associé lors de l'offloading.
module_name (str, facultatif, par défaut "") — Le nom du module.
skip_keys (str ou List[str], facultatif) — Une liste de clés à ignorer lors du déplacement des entrées ou des sorties entre les appareils.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.
tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], facultatif, par défaut None) — Une correspondance entre les pointeurs de données 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é pour tous les autres, au lieu de dupliquer la mémoire.

Attache récursivement AlignDevicesHook à tous les sous-modules d'un modèle donné qui possèdent des paramètres et/ou des buffers directs.

attach_align_device_hook_on_blocks

accelerate.hooks.attach_align_device_hook_on_blocks

< source >

Paramètres

module (torch.nn.Module) — Le module auquel nous souhaitons attacher les hooks.
execution_device (torch.device ou Dict[str, torch.device], facultatif) — L’appareil sur lequel les entrées et les poids du modèle doivent être placés avant le passage avant. Il peut s’agir d’un seul appareil pour l’ensemble du module, ou d’un dictionnaire associant le nom du module à l’appareil.
offload (bool, facultatif, par défaut False) — Indique si les poids doivent être déchargés après le passage avant. Il peut s'agir d'un booléen unique pour l'ensemble du module, ou d'un dictionnaire associant le nom du module à un booléen.
weights_map (Mapping[str, torch.Tensor], facultatif) — Lorsque les poids du modèle sont déchargés, une carte (éventuellement paresseuse) des noms de paramètres vers les valeurs des tenseurs.
offload_buffers (bool, facultatif, par défaut False) — Indique s'il faut inclure les buffers du module associé lors de l'offloading.
module_name (str, facultatif, par défaut "") — Le nom du module.
skip_keys (str ou List[str], facultatif) — Une liste de clés à ignorer lors du déplacement des entrées ou des sorties entre les appareils.
preload_module_classes (List[str], facultatif) — Une liste de classes dont les instances doivent charger tous leurs poids (y compris dans les sous-modules) au début du forward. Cela ne doit être utilisé que pour les classes possédant des sous-modules enregistrés mais non appelés directement pendant le forward, par exemple si une couche linéaire dense est enregistrée, mais qu'au forward, dense.weight et dense.bias sont utilisés dans certaines opérations au lieu d'appeler dense directement.
tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], facultatif, par défaut None) — Une correspondance entre les pointeurs de données 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é pour tous les autres, au lieu de dupliquer la mémoire.

Attache AlignDevicesHook à tous les blocs d'un modèle donné, si nécessaire.

attach_layerwise_casting_hooks

accelerate.big_modeling.attach_layerwise_casting_hooks

< source >

( module: Modulestorage_dtype: dtypecompute_dtype: dtypeskip_modules_pattern: str | tuple[str, ...] | None = Noneskip_modules_classes: tuple[type[torch.nn.Module], ...] | None = Nonenon_blocking: bool = False )

Paramètres

module (torch.nn.Module) — Le module dont les modules feuilles seront convertis en un type de données de haute précision pour le calcul et en un type de données de basse précision pour le stockage.
storage_dtype (torch.dtype) — Le dtype vers lequel convertir le module avant/après le passage avant pour le stockage.
compute_dtype (torch.dtype) — Le dtype vers lequel convertir le module lors de la passe avant pour le calcul.
skip_modules_pattern (tuple[str, ...], par défaut None) — Une liste de motifs pour correspondre aux noms des modules à ignorer lors du processus de conversion par couche. Si défini à None et que skip_modules_classes est None, la conversion par couche est appliquée directement au module plutôt qu’à ses sous-modules internes.
skip_modules_classes (tuple[type[torch.nn.Module], ...], par défaut None) — Une liste de classes de modules à ignorer lors du processus de conversion par couche.
non_blocking (bool, par défaut False) — Si True, les opérations de conversion des poids sont non bloquantes.

Applique un castage par couche à un module donné. Le module attendu ici est un nn.Module de PyTorch. Cela est utile pour réduire les besoins en mémoire lorsque l’on ne souhaite pas quantifier entièrement un modèle. Les paramètres du modèle peuvent être conservés, par exemple, en torch.float8_e4m3fn et convertis vers une précision supérieure comme torch.bfloat16 pendant la passe avant, puis reconvertis en torch.float8_e4m3fn pour réaliser des économies de mémoire.

Exemple :

>>> from accelerate.hooks import attach_layerwise_casting_hooks
>>> from transformers import AutoModelForCausalLM
>>> import torch

>>> # Model
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)

>>> # Attach hooks and perform inference
>>> attach_layerwise_casting_hooks(model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
>>> with torch.no_grad():
...     model(...)

Les utilisateurs peuvent également passer des modules qu'ils souhaitent éviter de voir leur type de données réduit.

>>> attach_layerwise_casting_hooks(
...     model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16, skip_modules_pattern=["norm"]
... )

Suppression des hooks

remove_hook_from_module

accelerate.hooks.remove_hook_from_module

< source >

( module: Modulerecurse = False ) → torch.nn.Module

Paramètres

module (torch.nn.Module) — Le module auquel attacher un hook.
recurse (bool, facultatif) — Indique s'il faut supprimer les hooks de manière récursive

Retourne

torch.nn.Module

Le même module, avec le hook détaché (le module est modifié en place, donc le résultat peut être ignoré).

Supprime tout hook attaché à un module via add_hook_to_module.

remove_hook_from_submodules

accelerate.hooks.remove_hook_from_submodules

< source >

( module: Module )

Paramètres

module (torch.nn.Module) — Le module sur lequel supprimer tous les hooks.

Supprime récursivement tous les hooks attachés aux sous-modules d'un modèle donné.

Utilitaires

has_offloaded_params

accelerate.utils.has_offloaded_params

< source >

( module: Module ) → bool

Paramètres

module (torch.nn.Module) — Le module à vérifier pour un hook de déchargement.

Retourne

bool

True si le module a un hook de déchargement et que le déchargement est activé, False sinon.

Vérifie si un module possède des paramètres déchargés en examinant si le module donné a un AlignDevicesHook attaché avec le déchargement activé

align_module_device

accelerate.utils.align_module_device

< source >

( module: Moduleexecution_device: torch.device | None = None )

Paramètres

module (torch.nn.Module) — Module avec des paramètres à aligner.
execution_device (torch.device, facultatif) — Si fourni, remplace le périphérique d’exécution du module dans le contexte. Sinon, utilise le périphérique d’exécution du hook ou passe

Gestionnaire de contexte qui déplace les paramètres d’un module vers le périphérique d’exécution spécifié.

Update on GitHub

←Journalisation Gestionnaires de kwargs→