Calculateur de VRAM pour le fine-tuning (LoRA, QLoRA, complet)

Voir les résultats · 11,9 Go

Configuration de l'entraînement

Méthode

La base figée est stockée en NF4 4 bits avec double quantification ; seuls les adaptateurs sont entraînés.

Modules ciblés par LoRA
Poids de l'adaptateur

PEFT crée les poids des adaptateurs en fp32 ; le SFTTrainer de TRL les convertit en bf16 quand le modèle de base est quantifié (QLoRA). Choisissez fp32 pour PEFT seul.

Optimiseur

Mémoire GPU estimée

VRAM totale
Paramètres entraînables
41,94 M (0,52 %)
Poids, gradients, optimiseur
6,2 Go
Activations
0,8 Go

Plus petit GPU de la liste qui suffit : RTX 3060 12GB (12 Go), avec 1,0 Go de marge.

Sans gradient checkpointing : 21,1 Go.

Modèle : 8 030 261 248 paramètres, 32 couches, taille cachée 4 096, vocabulaire 128 256.

prepare_model_for_kbit_training de PEFT convertit les embeddings et la couche de sortie en fp32 : ajoutez 2,1 Go si votre script l'appelle.

Une estimation, pas une mesure : la mémoire des activations dépend du framework et de ses noyaux. Données des modèles et liste des GPU vérifiées le 2026-10-24.

Détail de la mémoire

Détail de la mémoire
PosteRègleMémoirePart
Poids de base figés (NF4 4 bits)0.5 B×Ψlin0.5\,\text{B} \times \Psi_{\text{lin}}3,49 Go29,3 %
Constantes de quantification0.127 bit×Ψlin0.127\,\text{bit} \times \Psi_{\text{lin}}0,11 Go0,93 %
Embeddings et couche de sortie (bf16)2 B×Ψemb2\,\text{B} \times \Psi_{\text{emb}}2,10 Go17,6 %
Poids des adaptateurs LoRA2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 Go0,7 %
Gradients des adaptateurs2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 Go0,7 %
États de l'optimiseur (adaptateurs)8 B×ΨLoRA8\,\text{B} \times \Psi_{\text{LoRA}}0,34 Go2,8 %
Activations (avec checkpointing)2sbhL+34sbh2sbhL + 34sbh0,82 Go6,9 %
Logits de sortie pour la perte10 B×sbV10\,\text{B} \times sbV2,63 Go22 %
Contexte et noyaux CUDA1.3 GB1.3\,\text{GB}1,30 Go10,9 %
Marge de sécurité10 %10\,\%0,97 Go8,1 %
VRAM totale11,92 Go100 %

Ψ\Psi est le nombre de paramètres, Ψlin\Psi_{\text{lin}} ceux des couches linéaires, Ψemb\Psi_{\text{emb}} ceux des embeddings et de la couche de sortie et ΨLoRA\Psi_{\text{LoRA}} ceux des adaptateurs ; ss est la longueur de séquence, bb le micro-batch, hh la taille cachée, LL le nombre de couches, VV le vocabulaire et NN le nombre de GPU. B désigne des octets ; un Go vaut un milliard d'octets.

Les GPU qui suffisent

  • RTX 3060 12GB 12 Go (12,9 Go)1,0 Go libres
  • RTX 4060 Ti 16GB 16 Go (17,2 Go)5,3 Go libres
  • RTX 4080 16 Go (17,2 Go)5,3 Go libres
  • Tesla P100 16GB 16 Go (17,2 Go)5,3 Go libres
  • RTX 3090 24 Go (25,8 Go)13,9 Go libres
  • RTX 4090 24 Go (25,8 Go)13,9 Go libres
  • Tesla P40 24 Go (25,8 Go)13,9 Go libres
  • MI50 32GB 32 Go (34,4 Go)22,5 Go libres
  • RTX 5090 32 Go (34,4 Go)22,5 Go libres
  • Tesla V100 32GB 32 Go (34,4 Go)22,5 Go libres
  • A100 40GB 40 Go (42,9 Go)31,0 Go libres
  • L40S 48 Go (51,5 Go)39,6 Go libres
  • RTX 4090 48GB 48 Go (51,5 Go)39,6 Go libres
  • RTX A6000 48 Go (51,5 Go)39,6 Go libres
  • A100 80GB 80 Go (85,9 Go)74,0 Go libres
  • H100 80GB 80 Go (85,9 Go)74,0 Go libres
  • H100 NVL 94 Go (100,9 Go)89,0 Go libres
  • RTX PRO 6000 96 Go (103,1 Go)91,2 Go libres
  • DGX Spark GB10 128 Go (137,4 Go)125,5 Go libres
  • H200 141 Go (151,4 Go)139,5 Go libres
  • B200 180 Go (193,3 Go)181,4 Go libres

Mémoire nominale d'après les fiches techniques des fabricants. Les fabricants comptent en gigaoctets binaires : une carte de 24 Go contient 25,8 milliards d'octets (entre parenthèses), et c'est ce chiffre qui sert à la comparaison, puisque le contexte CUDA est déjà dans le total. La MI50 n'a pas de version CUDA de bitsandbytes (QLoRA, AdamW 8 bits) ; la V100 et les cartes Pascal (P40, P100) n'ont pas de bf16, et en fp16 la mémoire est la même.

À 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 d×kd \times k reçoit r(d+k)r(d + k) 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, 4+8/64+32/(64⋅256)≈4,1274 + 8/64 + 32/(64 \cdot 256) \approx 4{,}127 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 34 sbh34\,sbh octets pour une longueur de séquence ss, un micro-batch bb et une taille cachée hh (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, 2 sbh2\,sbh, 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 WW les poids, GG les gradients, OO les états de l'optimiseur et la copie maîtresse, AA les activations et Λ\Lambda les logits, plus 1,3 Go pour le contexte CUDA et une marge de 10 % :

M=(W+G+O+A+Λ)×1,1+1,3 GoM = (W + G + O + A + \Lambda) \times 1{,}1 + 1{,}3\ \text{Go}

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

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ètreValeurSi absent
methodMéthodel'une des valeurs : full, lora, qloraqlora par défaut
architectureModèle personnalisél'une des valeurs : preset, custompreset par défaut
modelModèlel'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 = presetllama3.1-8b par défaut
parameters_billionsParamètresnombre; autorisé : 0.01–2000; utilisé avec architecture = customobligatoire
layersCouchesnombre entier; autorisé : 1–512; utilisé avec architecture = customobligatoire
hidden_sizeTaille cachée (hidden size)nombre entier; autorisé : 64–65536; utilisé avec architecture = customobligatoire
vocabulary_sizeTaille du vocabulairenombre entier; autorisé : 1–2000000; utilisé avec architecture = customobligatoire
tied_embeddingsEmbeddings partagés (tie_word_embeddings)true ou false; utilisé avec architecture = customfalse par défaut
optimizerOptimiseurl'une des valeurs : adamw, adamw_8bit, sgdadamw par défaut
master_weightsGarder une copie maîtresse des poids en fp32true ou false; utilisé avec method = fulltrue par défaut
lora_rankRang LoRA (r)nombre entier; autorisé : 1–1024; utilisé avec method = lora, qlora16 par défaut
lora_targetsModules ciblés par LoRAl'une des valeurs : qv, attention, all; utilisé avec method = lora, qloraall par défaut
adapter_precisionPoids de l'adaptateurl'une des valeurs : fp32, bf16; utilisé avec method = lora, qlorabf16 par défaut
sequence_lengthLongueur de séquence (tokens)nombre entier; autorisé : 1–10485762048 par défaut
batch_sizeMicro-batch par GPUnombre entier; autorisé : 1–10241 par défaut
gradient_checkpointingGradient checkpointingtrue ou falsetrue par défaut
fused_lossNoyau d'entropie croisée fusionné (Liger, Unsloth)true ou falsefalse par défaut
gpu_countNombre de GPUnombre entier; autorisé : 1–10241 par défaut
zero_stagePartitionnement (étape ZeRO)l'une des valeurs : 0, 1, 2, 30 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&parameters_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"]