Accelerate documentation

Charger de grands modèles en mémoire

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Charger de grands modèles en mémoire

Lors du chargement d'un modèle pré-entraîné dans PyTorch, le flux de travail habituel ressemble à ceci :

import torch

my_model = ModelClass(...)
state_dict = torch.load(checkpoint_file)
my_model.load_state_dict(state_dict)

En termes simples, ces étapes sont :

  1. Créer le modèle avec des poids initialisés aléatoirement
  2. Charger les poids du modèle (dans un dictionnaire généralement appelé state dict) depuis le disque
  3. Charger ces poids dans le modèle

Bien que cette approche fonctionne très bien pour les modèles de taille régulière, ce flux de travail présente des limites claires lorsque nous traitons un modèle très volumineux : à l'étape 1, nous chargeons une version complète du modèle en RAM et passons du temps à initialiser aléatoirement les poids (qui seront jetés à l'étape 3). À l'étape 2, nous chargeons une autre version complète du modèle en RAM, avec les poids pré-entraînés. Si vous chargez un modèle de 6 milliards de paramètres, cela signifie que vous aurez besoin de 24 Go de RAM pour chaque copie du modèle, soit 48 Go au total (la moitié pour charger le modèle en FP16).

Cette API est assez nouvelle et se trouve encore à un stade expérimental. Bien que nous nous efforcions de fournir une API stable, il est possible que certaines petites parties de l’API publique évoluent à l’avenir.

Comment le processus fonctionne : un aperçu rapide

Comment le processus fonctionne : travailler avec le code

Instanciation d'un modèle vide

The first tool Accelerate introduces to help with big models is a context manager init_empty_weights() that helps you initialize a model without using any RAM so that step 1 can be done on models of any size. Here is how it works:

from accelerate import init_empty_weights

with init_empty_weights():
    my_model = ModelClass(...)

Par exemple :

with init_empty_weights():
    model = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])

initialise un modèle vide avec un peu plus de 100 milliards de paramètres. En coulisses, cela s’appuie sur le périphérique meta introduit dans PyTorch 1.9. Pendant l’initialisation sous le gestionnaire de contexte, chaque fois qu’un paramètre est créé, il est immédiatement déplacé vers ce périphérique.

Vous ne pouvez pas déplacer directement sur le CPU ou un autre appareil un modèle initialisé de cette manière, car il ne contient aucune donnée. Il est également très probable qu’un passage avant avec ce modèle vide échoue, car toutes les opérations ne sont pas prises en charge sur l’appareil meta.

Points de contrôle fractionnés

Il est possible que votre modèle soit si volumineux qu’une seule copie ne tienne pas dans la RAM. Cela ne signifie pas qu’il ne peut pas être chargé : si vous disposez d’un ou de plusieurs GPU, cela représente davantage de mémoire disponible pour stocker votre modèle. Dans ce cas, il est préférable que votre checkpoint soit divisé en plusieurs fichiers plus petits que nous appelons des shards de checkpoint.

Accelerate gérera les points de contrôle fractionnés tant que vous respectez le format suivant : votre point de contrôle doit se trouver dans un dossier, avec plusieurs fichiers contenant les dictionnaires d'état partiels, et il doit y avoir un index au format JSON contenant un dictionnaire qui associe les noms de paramètres au fichier contenant leurs poids. Vous pouvez facilement fractionner votre modèle avec save_model(). Par exemple, nous pourrions avoir un dossier contenant :

first_state_dict.bin
index.json
second_state_dict.bin

avec index.json étant le fichier suivant :

{
  "linear1.weight": "first_state_dict.bin",
  "linear1.bias": "first_state_dict.bin",
  "linear2.weight": "second_state_dict.bin",
  "linear2.bias": "second_state_dict.bin"
}

et first_state_dict.bin contenant les poids de "linear1.weight" et "linear1.bias", second_state_dict.bin ceux de "linear2.weight" et "linear2.bias"

Chargement des poids

Le second outil introduit par Accelerate est la fonction load_checkpoint_and_dispatch(), qui vous permet de charger un point de contrôle dans votre modèle vide. Elle prend en charge les points de contrôle complets (un seul fichier contenant l’intégralité du state dict) ainsi que les points de contrôle fragmentés. Elle répartit également automatiquement ces poids sur les dispositifs disponibles (GPU, RAM CPU), de sorte que, si vous chargez un point de contrôle fragmenté, l’utilisation maximale de la RAM sera égale à la taille du plus grand fragment.

Si vous souhaitez utiliser l'inférence de grands modèles avec des modèles Transformers, consultez cette documentation.

Voici comment nous pouvons utiliser cela pour charger le modèle GPT2-1.5B.

Téléchargeons la version en shards de ce modèle.

pip install huggingface_hub
from huggingface_hub import snapshot_download
checkpoint = "marcsun13/gpt2-xl-linear-sharded"
weights_location = snapshot_download(repo_id=checkpoint)

Afin d'initialiser le modèle, nous utiliserons la bibliothèque minGPT.

git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    model = GPT(model_config)

Ensuite, chargez le point de contrôle que nous venons de télécharger avec :

from accelerate import load_checkpoint_and_dispatch

model = load_checkpoint_and_dispatch(
    model, checkpoint=weights_location, device_map="auto", no_split_module_classes=['Block']
)

En passant device_map="auto", nous indiquons à Accelerate de déterminer automatiquement où placer chaque couche du modèle en fonction des ressources disponibles :

  • d'abord, nous utilisons l'espace maximal disponible sur le(s) GPU
  • si nous avons encore besoin d'espace, nous stockons les poids restants sur le CPU
  • s'il n'y a pas assez de RAM, nous stockons les poids restants sur le disque dur sous forme de tenseurs mappés en mémoire

no_split_module_classes

Ce paramètre indiquera que certains modules portant le nom "Block" ne doivent pas être répartis sur différents appareils. Vous devez y indiquer tous les blocs qui contiennent une connexion résiduelle d'une manière ou d'une autre.

Le device_map

Vous pouvez consulter le device_map choisi par Accelerate en accédant à l'attribut hf_device_map de votre modèle :

model.hf_device_map
{'transformer.wte': 0,
 'transformer.wpe': 0,
 'transformer.drop': 0,
 'transformer.h.0': 0,
 ...
 'transformer.h.21': 0, 
 'transformer.h.22': 1, 
 'transformer.h.23': 1, 
 'transformer.h.24': 1,
 ...
 'transformer.h.47': 1, 
 'transformer.ln_f': 1, 
 'lm_head': 1}

Il est tout à fait possible de créer votre propre carte de périphériques pour les couches à utiliser, en spécifiant le périphérique GPU à utiliser (un nombre), "cpu" ou "disk", et de la transmettre ainsi :

device_map = {
    "transformer.wte": "cpu",
    "transformer.wpe": 0,
    "transformer.drop": "cpu",
    "transformer.h.0": "disk"
}

model = load_checkpoint_and_dispatch(
    model, checkpoint=weights_location, device_map=device_map
)

Exécuter le modèle

Maintenant que c'est fait, notre modèle est réparti sur plusieurs appareils, et peut-être sur le disque dur. Mais il peut toujours être utilisé comme un modèle PyTorch classique :

from mingpt.bpe import BPETokenizer
tokenizer = BPETokenizer()
inputs = tokenizer("Hello, my name is").to(0)

outputs = model.generate(x1, max_new_tokens=10, do_sample=False)[0]
tokenizer.decode(outputs.cpu().squeeze())

En coulisses, Accelerate a ajouté des hooks au modèle, de sorte que :

  • à chaque couche, les entrées sont placées sur le bon appareil (ainsi, même si votre modèle est réparti sur plusieurs GPU, cela fonctionne)
  • pour les poids déchargés sur le CPU, ils sont placés sur un GPU juste avant le passage avant et nettoyés juste après
  • pour les poids déchargés sur le disque dur, ils sont chargés en RAM puis placés sur un GPU juste avant le passage avant, puis nettoyés juste après

De cette manière, votre modèle peut effectuer de l’inférence même s’il ne tient pas sur l’un des GPU ou dans la RAM du CPU !

Cela ne prend en charge que l’inférence de votre modèle, pas l’entraînement. La plupart des calculs sont effectués dans des gestionnaires de contexte torch.no_grad() afin d’éviter de consommer de la mémoire GPU avec des activations intermédiaires.

Concevoir une carte de périphériques

Vous pouvez laisser Accelerate gérer le calcul de la carte des dispositifs en définissant device_map sur l'une des options prises en charge ("auto", "balanced", "balanced_low_0", "sequential") ou en en créant un vous-même si vous souhaitez un contrôle plus fin sur l'emplacement de chaque couche.

Vous pouvez dériver toutes les tailles du modèle (et donc calculer un device_map) sur un modèle situé sur le meta device.

Toutes les options produiront le même résultat lorsque vous ne disposez pas de mémoire GPU suffisante pour accueillir le modèle entier (ce qui consiste à placer sur le GPU tout ce qui peut y tenir, puis à décharger les poids sur le CPU, voire sur le disque si la RAM est insuffisante).

Lorsque la mémoire GPU disponible est supérieure à la taille du modèle, voici la différence entre chaque option :

  • "auto" et "balanced" répartissent le modèle de manière uniforme sur toutes les GPU disponibles, ce qui vous permet d’utiliser une taille de lot supérieure à 1.
  • "balanced_low_0" répartit le modèle de manière uniforme sur tous les GPU, à l'exception du premier, et n'y place que ce qui ne tient pas sur les autres. Cette option est idéale lorsque vous devez utiliser le GPU 0 pour certains traitements des sorties, comme lors de l'utilisation de la fonction generate pour les modèles Transformers
  • "sequential" remplira la GPU 0 autant que possible, puis passera à la GPU 1, et ainsi de suite (les dernières GPU ne seront donc pas utilisées si ce n’est pas nécessaire).

Les options "auto" et "balanced" produisent actuellement les mêmes résultats, mais le comportement de "auto" pourrait évoluer à l'avenir si nous trouvons une stratégie plus pertinente, tandis que "balanced" restera stable.

Notez d'abord que vous pouvez limiter la mémoire utilisée sur chaque GPU en utilisant l'argument max_memory (disponible dans infer_auto_device_map() et dans toutes les fonctions qui l'utilisent). Lors de la configuration de max_memory, vous devez transmettre un dictionnaire contenant les identifiants des GPU (par exemple 0, 1, etc.) et la clé "cpu" pour la quantité maximale de RAM que vous souhaitez utiliser pour l'offload CPU. Les valeurs peuvent être soit un entier (en octets), soit une chaîne de caractères représentant un nombre avec son unité, comme "10GiB" ou "10GB".

Voici un exemple où nous ne souhaitons pas utiliser plus de 10GiB sur chacun des deux GPU et plus de 30GiB de RAM CPU pour les poids du modèle :

from accelerate import infer_auto_device_map

device_map = infer_auto_device_map(my_model, max_memory={0: "10GiB", 1: "10GiB", "cpu": "30GiB"})

Lors de la première allocation dans PyTorch, les noyaux CUDA sont chargés, ce qui consomme environ 1 à 2 Go de mémoire selon le GPU. Par conséquent, la mémoire réellement disponible est toujours inférieure à la taille nominale du GPU. Pour vérifier la quantité de mémoire effectivement utilisée, exécutez torch.ones(1).cuda() et observez l'utilisation de la mémoire.

Par conséquent, lorsque vous créez des cartes mémoire avec max_memory, veillez à ajuster la mémoire disponible en conséquence afin d'éviter les erreurs de mémoire insuffisante.

De plus, si vous effectuez des opérations supplémentaires sur vos sorties sans les renvoyer sur le CPU (par exemple à l’intérieur de la méthode generate de Transformers) et si vous avez placé vos entrées sur un GPU, ce GPU consommera plus de mémoire que les autres (Accelerate renvoie toujours la sortie sur l’appareil de l’entrée). Par conséquent, si vous souhaitez optimiser la taille maximale du lot et que vous disposez de plusieurs GPU, allouez moins de mémoire au premier GPU. Par exemple, avec BLOOM-176B sur une configuration 8x80 A100, la répartition proche de l’idéal est :

max_memory = {0: "30GIB", 1: "46GIB", 2: "46GIB", 3: "46GIB", 4: "46GIB", 5: "46GIB", 6: "46GIB", 7: "46GIB"}

comme vous pouvez le constater, nous avons alloué environ 50 % de mémoire en plus aux 7 GPU restants par rapport au GPU 0.

Si vous choisissez de concevoir entièrement le device_map vous-même, il doit s’agir d’un dictionnaire dont les clés sont les noms de modules de votre modèle et les valeurs sont un identifiant d’appareil valide (par exemple un entier pour les GPU) ou "cpu" pour le déchargement sur CPU, "disk" pour le déchargement sur disque. Les clés doivent couvrir l’ensemble du modèle, vous pouvez alors définir votre carte d’appareils comme vous le souhaitez : par exemple, si votre modèle comporte deux blocs (disons block1 et block2) contenant chacun trois couches linéaires (disons linear1, linear2 et linear3), une carte d’appareils valide peut être :

device_map = {"block1": 0, "block2": 1}

un autre exemple valide pourrait être :

device_map = {"block1": 0, "block2.linear1": 0, "block2.linear2": 1, "block2.linear3": 1}

En revanche, celui-ci n'est pas valide car il ne couvre pas tous les paramètres du modèle :

device_map = {"block1": 0, "block2.linear1": 1, "block2.linear2": 1}

Pour être le plus efficace possible, assurez-vous que votre carte de périphériques place les paramètres sur les GPU de manière séquentielle (par exemple, ne placez pas l’un des premiers poids sur le GPU 0, puis des poids sur le GPU 1 et le dernier poids de nouveau sur le GPU 0) afin d’éviter de nombreux transferts de données entre les GPU.

Offload CPU uniquement

Si vous souhaitez décharger votre modèle sur le CPU, vous pouvez utiliser cpu_offload(). En conséquence, tous les paramètres du modèle seront déchargés et une seule copie du state dict du modèle sera conservée. Lors du forward pass, les paramètres seront extraits de ce state dict, placés sur le périphérique d'exécution et transmis au fur et à mesure de leur besoin, puis à nouveau déchargés.

cpu_offload(model, execution_device)

Vous pouvez également utiliser cpu_offload_with_hook(). Cette fonction déplace le 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 de nouveau déchargé que lorsque la méthode offload du hook retourné est appelée. De plus, cpu_offload_with_hook() est plus performant mais moins économe en mémoire. Il est utile pour les pipelines exécutant un modèle dans une boucle :

model_1, hook_1 = cpu_offload_with_hook(model_1, execution_device)
model_2, hook_2 = cpu_offload_with_hook(model_2, execution_device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, execution_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()

Offload disque uniquement

Pour effectuer un déchargement sur disque, vous pouvez utiliser disk_offload(). En conséquence, tous les paramètres du modèle seront déchargés sous forme de 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 passé, au fur et à mesure de leur besoin, puis déchargés à nouveau.

disk_offload(model, offload_dir, execution_device)

Limites et développements ultérieurs

Nous sommes conscients des limitations actuelles de l'API :

  • infer_auto_device_map() (ou device_map="auto" dans load_checkpoint_and_dispatch()) tente de maximiser la mémoire GPU et CPU disponible au moment de son exécution. Bien que PyTorch soit très efficace pour gérer la mémoire GPU (et la restituer lorsqu’elle n’est plus nécessaire), ce n’est pas tout à fait le cas pour Python et la mémoire CPU. Par conséquent, une carte de dispositifs calculée automatiquement peut s’avérer trop gourmande en ressources CPU. Déplacez quelques modules sur le dispositif disque si vous rencontrez des plantages dus à un manque de mémoire.
  • infer_auto_device_map() (ou device_map="auto" dans load_checkpoint_and_dispatch()) attribue les appareils de manière séquentielle (afin d’éviter de déplacer les éléments d’un appareil à l’autre) ; ainsi, si votre première couche est plus grande que la taille de votre GPU, tout finira par être placé sur le CPU/Disk.
  • load_checkpoint_and_dispatch() et load_checkpoint_in_model() n’effectuent actuellement aucune vérification de la cohérence de votre state dict par rapport à votre modèle (ce problème sera corrigé dans une future version). Vous pourriez donc rencontrer des erreurs inattendues si vous tentez de charger un checkpoint contenant des clés incohérentes ou manquantes.
  • Le parallélisme de modèle utilisé lorsque votre modèle est réparti sur plusieurs GPU est naïf et non optimisé, ce qui signifie qu'un seul GPU fonctionne à un instant donné tandis que les autres restent inactifs.
  • Lorsque les poids sont déchargés sur le CPU/le disque dur, il n'y a pas de pré-chargement (pour l'instant, nous travaillerons sur ce point pour les versions futures), ce qui signifie que les poids sont transférés sur le GPU au moment où ils sont nécessaires et non avant.
  • Le déchargement sur disque dur peut être très lent si le matériel sur lequel vous exécutez le code ne dispose pas d'une communication rapide entre le disque et le CPU (comme les NVMes).
Update on GitHub