À propos de cet outil
Le fine-tuning d'un modèle de langage demande bien plus de mémoire GPU que son exécution. En plus des poids, le GPU garde les gradients, les états de l'optimiseur et les activations de chaque couche jusqu'à la rétropropagation. Ce calculateur additionne ces postes pour le fine-tuning complet, LoRA et QLoRA, pour un modèle de la liste ou un modèle que vous décrivez, et indique quels GPU courants ont assez de place.
Chaque poste est affiché avec sa règle et sa source, car les calculateurs de fine-tuning divergent souvent du simple au double : l'un compte 18 octets par paramètre, l'autre 12, l'un oublie les logits, l'autre suppose le checkpointing sans le dire. Ici, chaque hypothèse est un réglage visible que vous pouvez modifier.
Comment la mémoire est estimée
Le fine-tuning complet en précision mixte garde, pour chaque paramètre, 2 octets de poids en bf16, 2 octets de gradients, une copie maîtresse en fp32 de 4 octets et 8 octets de moment et de variance d'AdamW : 16 octets, le décompte de l'article ZeRO (Rajbhandari et al., 2020). AdamW 8 bits stocke 2 octets d'état au lieu de 8, et SGD avec momentum 4. Les étapes 1, 2 et 3 de ZeRO répartissent entre les GPU d'abord les états de l'optimiseur, puis les gradients, puis les poids.
LoRA fige le modèle de base à 2 octets par paramètre et entraîne deux petites matrices à côté de chaque poids adapté : un poids de taille reçoit paramètres d'adaptateur (Hu et al., 2021). Eux seuls ont des gradients et des états d'optimiseur : PEFT les crée en fp32 (16 octets chacun avec AdamW), et le SFTTrainer de TRL les convertit en bf16 pour les modèles quantifiés (12 octets). QLoRA stocke les couches linéaires figées en NormalFloat 4 bits avec double quantification, bits par paramètre (Dettmers et al., 2023), tandis que les embeddings et la couche de sortie restent en bf16.
Les activations dépendent des données. Chaque couche conserve environ octets pour une longueur de séquence , un micro-batch et une taille cachée (Korthikanti et al., 2022) ; FlashAttention supprime le terme de la matrice d'attention. Le gradient checkpointing ne garde que l'entrée de chaque couche, , et recalcule une couche à la fois. La perte ajoute environ 10 octets par token et par entrée du vocabulaire pour les logits, sauf si un noyau fusionné les calcule par morceaux. Avec les poids, les gradients, les états de l'optimiseur et la copie maîtresse, les activations et les logits, plus 1,3 Go pour le contexte CUDA et une marge de 10 % :
Pourquoi les calculateurs de fine-tuning divergent, et ce qui n'est pas compté
Trois hypothèses expliquent l'essentiel des écarts entre calculateurs, et chacune est ici un réglage. Octets par paramètre : le guide d'entraînement de Hugging Face en compte 18 pour AdamW en précision mixte (gradients en fp32 et seconde copie des poids), l'article ZeRO 16, et les « plus de 780 Go » de l'article QLoRA pour le fine-tuning 16 bits de LLaMA 65B correspondent à 12, sans copie maîtresse ; désactivez les poids maîtres pour retrouver ce chiffre. Logits : avec le vocabulaire de 128 256 tokens de Llama 3, les logits de 2 048 tokens occupent 2,6 Go, ce que les noyaux d'entropie croisée fusionnés évitent. Checkpointing : pour Llama 3.1 8B à 2 048 tokens, le désactiver fait passer les activations de 0,8 à 9,1 Go.
Ne sont pas modélisés : les tampons éphémères à l'intérieur d'une opération (le poids déquantifié d'une couche en QLoRA, la couche que ZeRO-3 rassemble), le déchargement vers le CPU et les optimiseurs paginés, les modèles mixture-of-experts, les encodeurs visuels et l'entraînement par préférences comme DPO, qui garde un second modèle de référence. Servez-vous du résultat pour planifier, puis vérifiez les premières étapes avec torch.cuda.max_memory_allocated().
Exemple
Vérification avec l'article QLoRA. LLaMA 65B compte 65,29 milliards de paramètres, 80 couches et une taille cachée de 8 192. En QLoRA, avec des adaptateurs bf16 de rang 64 sur toutes les couches linéaires comme dans l'article, et des séquences de 512 tokens : les poids 4 bits occupent 32,38 Go, les constantes de quantification 1,03 Go et les embeddings bf16 1,05 Go ; les 799,5 millions de paramètres d'adaptateurs occupent 1,60 Go, leurs gradients 1,60 Go et leurs états AdamW 6,40 Go ; les activations avec checkpointing 0,81 Go et les logits 0,16 Go. Soit 45,0 Go de tenseurs, et 50,8 Go avec le contexte de 1,3 Go et la marge de 10 %. Une carte de 48 Go contient 51,5 milliards d'octets : le GPU unique de 48 Go de l'article suffit donc, avec 0,7 Go de marge ; les optimiseurs paginés de l'article donnent encore du jeu en déplaçant les 6,4 Go d'états de l'optimiseur vers la mémoire du CPU quand le GPU manque de place.
Vérification avec l'article ZeRO. Pour un modèle de 7,5 milliards de paramètres sur 64 GPU, l'article donne 120 Go d'états du modèle par GPU sans partitionnement, 31,4 Go à l'étape 1, 16,6 Go à l'étape 2 et 1,88 Go à l'étape 3. Les règles de cette page donnent 120 ; 31,41 ; 16,64 et 1,875 Go.
Llama 3.1 8B. LoRA de rang 16 sur toutes les couches linéaires (41,9 millions de paramètres d'adaptateurs en bf16), 2 048 tokens, un micro-batch de 1 et le checkpointing : 16,06 Go de poids figés, 0,50 Go pour les adaptateurs avec leurs gradients et états d'optimiseur, 0,82 Go d'activations et 2,63 Go de logits, 23,3 Go en tout. Unsloth indique 22 Go au minimum pour un LoRA 16 bits sur un modèle 8B. Le même entraînement en QLoRA demande 11,9 Go, ou 9,0 Go avec une perte fusionnée.
Questions fréquentes
Combien de VRAM faut-il pour le fine-tuning d'un modèle 7B ou 8B ?
En QLoRA, environ 9 à 12 Go à 2 048 tokens avec un micro-batch de 1 : 11,9 Go avec les réglages par défaut et 9,0 Go avec une perte fusionnée. Une carte de 12 Go (12,9 milliards d'octets) suffit tout juste ; 16 Go laissent de la marge pour des séquences plus longues. Un LoRA 16 bits demande environ 23 Go, donc une carte de 24 Go. Le fine-tuning complet avec AdamW demande environ 146 Go, donc plusieurs GPU avec ZeRO ou FSDP. Des séquences plus longues et des batchs plus grands ajoutent de la mémoire d'activations ; le calculateur indique combien.
Quelle différence de mémoire entre LoRA et QLoRA ?
Les deux entraînent les mêmes petits adaptateurs ; la différence tient au modèle de base figé. LoRA le garde en bf16, à 2 octets par paramètre, QLoRA en NF4 4 bits, à environ 0,52 octet. Pour Llama 3.1 8B, cela fait 16,1 Go contre 5,7 Go, embeddings bf16 compris. QLoRA s'entraîne un peu plus lentement, car chaque couche est déquantifiée à la volée.
Pourquoi le fine-tuning complet demande-t-il 16 octets par paramètre ?
L'entraînement en précision mixte calcule en bf16 (2 octets de poids et 2 de gradients par paramètre), mais met à jour une copie maîtresse en fp32 (4 octets), et AdamW garde deux statistiques fp32 par paramètre, le moment et la variance (8 octets). Un modèle 8B demande donc environ 128 Go avant même les activations. AdamW 8 bits ramène ce chiffre à 10 octets par paramètre, et ZeRO ou FSDP répartissent le total entre les GPU.
Le gradient checkpointing réduit-il la mémoire ?
Oui, celle des activations. Pour Llama 3.1 8B à 2 048 tokens, les activations passent de 9,1 à 0,8 Go, car seule l'entrée de chaque couche est conservée et le reste est recalculé pendant la rétropropagation. Le prix est une passe avant supplémentaire : Korthikanti et al. ont mesuré jusqu'à 30 à 40 % de temps d'entraînement en plus.
Comment répartir le fine-tuning sur plusieurs GPU ?
Avec DeepSpeed ZeRO ou PyTorch FSDP. L'étape 1 répartit les états de l'optimiseur, l'étape 2 aussi les gradients et l'étape 3 (partitionnement complet de FSDP) aussi les poids. Le fine-tuning complet de Llama 3.1 8B sur huit GPU à l'étape 3 demande environ 22,8 Go par GPU. Les activations ne sont pas réparties : chaque GPU traite son propre micro-batch. Saisissez le nombre de GPU pour voir la mémoire nécessaire à chacun.
Sources
- Rajbhandari et al. (2020), ZeRO: Memory Optimizations Toward Training Trillion Parameter Models
- Hu et al. (2021), LoRA: Low-Rank Adaptation of Large Language Models
- Dettmers et al. (2023), QLoRA: Efficient Finetuning of Quantized LLMs
- Korthikanti et al. (2022), Reducing Activation Recomputation in Large Transformer Models
- Hugging Face Transformers: GPU memory usage in training
- Hugging Face PEFT: LoRA developer guide
Lien avec vos valeurs
Ajoutez ces paramètres à l'adresse de cette page pour l'ouvrir avec les valeurs déjà remplies, par exemple pour partager un calcul ou pour y renvoyer depuis un assistant IA. Le résultat est calculé dans le navigateur : le HTML de la page montre un exemple avec les valeurs par défaut, et l'outil définit l'attribut data-url-params une fois les valeurs du lien appliquées.
| Paramètre | Valeur | Si absent |
|---|---|---|
methodMéthode | l'une des valeurs : full, lora, qlora | qlora par défaut |
architectureModèle personnalisé | l'une des valeurs : preset, custom | preset par défaut |
modelModèle | l'une des valeurs : llama3.2-1b, llama3.2-3b, qwen3-4b, mistral-7b-v0.3, qwen2.5-7b, llama3.1-8b, qwen3-8b, phi-4, qwen3-14b, qwen3-32b, llama3.3-70b, llama-2-7b, llama-7b, llama-65b; utilisé avec architecture = preset | llama3.1-8b par défaut |
parameters_billionsParamètres | nombre; autorisé : 0.01–2000; utilisé avec architecture = custom | obligatoire |
layersCouches | nombre entier; autorisé : 1–512; utilisé avec architecture = custom | obligatoire |
hidden_sizeTaille cachée (hidden size) | nombre entier; autorisé : 64–65536; utilisé avec architecture = custom | obligatoire |
vocabulary_sizeTaille du vocabulaire | nombre entier; autorisé : 1–2000000; utilisé avec architecture = custom | obligatoire |
tied_embeddingsEmbeddings partagés (tie_word_embeddings) | true ou false; utilisé avec architecture = custom | false par défaut |
optimizerOptimiseur | l'une des valeurs : adamw, adamw_8bit, sgd | adamw par défaut |
master_weightsGarder une copie maîtresse des poids en fp32 | true ou false; utilisé avec method = full | true par défaut |
lora_rankRang LoRA (r) | nombre entier; autorisé : 1–1024; utilisé avec method = lora, qlora | 16 par défaut |
lora_targetsModules ciblés par LoRA | l'une des valeurs : qv, attention, all; utilisé avec method = lora, qlora | all par défaut |
adapter_precisionPoids de l'adaptateur | l'une des valeurs : fp32, bf16; utilisé avec method = lora, qlora | bf16 par défaut |
sequence_lengthLongueur de séquence (tokens) | nombre entier; autorisé : 1–1048576 | 2048 par défaut |
batch_sizeMicro-batch par GPU | nombre entier; autorisé : 1–1024 | 1 par défaut |
gradient_checkpointingGradient checkpointing | true ou false | true par défaut |
fused_lossNoyau d'entropie croisée fusionné (Liger, Unsloth) | true ou false | false par défaut |
gpu_countNombre de GPU | nombre entier; autorisé : 1–1024 | 1 par défaut |
zero_stagePartitionnement (étape ZeRO) | l'une des valeurs : 0, 1, 2, 3 | 0 par défaut |
Exemples
?method=qlora&model=llama-65b&lora_rank=64&adapter_precision=bf16&sequence_length=512?method=lora&model=llama3.1-8b&lora_rank=16&lora_targets=all&sequence_length=2048&batch_size=1?method=full&model=llama3.1-8b&gpu_count=8&zero_stage=3?method=qlora&architecture=custom¶meters_billions=12&layers=48&hidden_size=3840&vocabulary_size=262144&tied_embeddings=true
Écrivez les décimales avec un point. Encodez un espace en %20, + en %2B, # en %23 et & en %26.
Éléments de résultat: [data-result-block="fine-tuning-vram"]