Calculateur VRAM pour LLM : Estimez vos besoins en mémoire GPU

Combien de VRAM faut-il pour faire tourner Llama 3 70B ? Et pour fine-tuner Mistral 7B ? Ce calculateur vous donne des estimations précises basées sur les formules utilisées en production.

Comment utiliser ce calculateur ?

Mode Inférence

Utilisez ce mode pour estimer la VRAM nécessaire pour faire tourner un modèle (génération de texte, chat, etc.).

Paramètres clés :

• Paramètres : Nombre de paramètres du modèle (ex: 7B pour Mistral 7B)
• Précision :
  • FP32 (32-bit) : Précision maximale, 4 bytes/param
  • FP16 (16-bit) : Standard production, 2 bytes/param
  • INT8 (8-bit) : Quantization, 1 byte/param, -2% qualité
  • INT4 (4-bit) : Forte quantization, 0.5 bytes/param, -5% qualité
• Batch Size : Nombre de requêtes traitées simultanément
• Longueur Séquence : Nombre maximum de tokens (prompt + génération)

Exemple : Llama 3.1 8B en FP16 avec batch=1 et seq_len=2048 → ~18 GB

Mode Fine-tuning / Training

Utilisez ce mode pour estimer la VRAM nécessaire pour entraîner ou fine-tuner un modèle.

Options avancées :

• Gradient Checkpointing : Trade temps vs mémoire, réduit VRAM de ~30%
• LoRA : Fine-tune seulement ~1% des paramètres, réduit VRAM de ~60%
• QLoRA : LoRA + quantization 4-bit, réduit VRAM de ~75%
• Optimizer :
  • Adam : 12 bytes/param (momentum + variance)
  • SGD : 4 bytes/param (momentum seulement)
  • AdamW 8-bit : 6 bytes/param (quantized)

Exemple : Fine-tuning Mistral 7B avec QLoRA → ~12 GB (vs 112 GB full fine-tuning)

Formules de calcul

VRAM Modèle

VRAM_modèle = Nombre_params × Bytes_par_param

Exemples:
- Llama 3.1 8B en FP16 : 8B × 2 = 16 GB
- Llama 3.1 70B en INT4 : 70B × 0.5 = 35 GB

VRAM KV Cache

Le KV Cache stocke les états attention pour éviter les recalculs :

VRAM_KV = 2 × Layers × Heads × Dim × Seq_len × Batch × Bytes

Approximation simplifiée:
VRAM_KV ≈ 0.8% × Params × Seq_len × Batch × Bytes

VRAM Activations

VRAM_activations ≈ Batch × Seq_len × Hidden_dim × Layers × 8-12 bytes

Avec gradient checkpointing:
VRAM_activations_checkpoint ≈ VRAM_activations × 0.3

VRAM Training (Full Fine-tuning)

VRAM_training = VRAM_model + VRAM_optimizer + VRAM_gradients

Avec Adam optimizer:
VRAM_optimizer = Params × 12 bytes (momentum + variance)
VRAM_gradients = Params × Bytes_par_param

Total ≈ Params × (Bytes_param + 12 + Bytes_param)
      ≈ Params × (2 × Bytes_param + 12)
      ≈ Params × 16 bytes (pour FP16)

VRAM Training (LoRA)

Trainable_params = Total_params × 0.01 (1% avec LoRA)

VRAM_LoRA = VRAM_model (frozen)
          + Trainable_params × (Bytes + Optimizer_bytes)

Réduction typique: ~60% vs full fine-tuning

VRAM Training (QLoRA)

VRAM_QLoRA = VRAM_model (INT4, 0.5 bytes/param)
           + Trainable_params (1%) × (2 bytes + Optimizer)

Réduction typique: ~75% vs full fine-tuning

Exemples concrets

Inference Llama 3.1 70B

Modèle: 70B paramètres
Précision: INT4 (0.5 bytes/param)
Batch: 1
Seq length: 4096 tokens

VRAM modèle: 70B × 0.5 = 35 GB
VRAM KV Cache: ~3 GB
VRAM Activations: ~2 GB

Total: ~40 GB → A100 40GB ou 2× RTX 4090

Fine-tuning Mistral 7B avec QLoRA

Modèle: 7B paramètres
Méthode: QLoRA (INT4 + LoRA)
Batch: 4
Seq length: 2048

VRAM modèle (INT4): 7B × 0.5 = 3.5 GB
VRAM LoRA (1% trainable): ~1 GB
VRAM Optimizer: ~1 GB
VRAM Gradients: ~1 GB
VRAM Activations: ~4 GB

Total: ~10.5 GB → RTX 3060 12GB, RTX 4070 Ti

Training from Scratch GPT-2 1.5B

Modèle: 1.5B paramètres
Precision: FP32 (4 bytes/param)
Batch: 16
Seq length: 1024
Optimizer: Adam

VRAM modèle: 1.5B × 4 = 6 GB
VRAM optimizer: 1.5B × 12 = 18 GB
VRAM gradients: 1.5B × 4 = 6 GB
VRAM activations: ~8 GB

Total: ~38 GB → A100 40GB

Optimisations pour réduire VRAM

Quantization (Inference)

Recommandation : INT4 pour modèles >70B, FP16 pour modèles <13B

LoRA / QLoRA (Fine-tuning)

# Full fine-tuning Llama 3.1 70B
VRAM: ~1,120 GB (impossible sans 10+ A100)

# LoRA
VRAM: ~450 GB (4-5× A100 80GB)

# QLoRA
VRAM: ~48 GB (1× A100 40GB ou 2× RTX 4090) ✅

Gain : QLoRA = -95% VRAM vs full fine-tuning

Gradient Checkpointing

# Sans checkpointing
Activations: 100%

# Avec checkpointing
Activations: ~30%
Training time: +20% (recalcul activations)

Trade-off : -70% VRAM activations, +20% temps

Réduire Batch Size

Batch 32: 100% VRAM
Batch 16: ~55% VRAM
Batch 8:  ~30% VRAM
Batch 1:  ~10% VRAM (baseline)

Impact : Linéaire sur VRAM, mais ralentit training

Mixed Precision Training

# FP32 partout
VRAM: 100%

# Mixed FP16/FP32
VRAM: ~50%
Accuracy: ~99.9%

Recommandation : Standard depuis 2020, toujours activer

GPU recommandés par use case

Développement / Prototypage

Budget <$1,000 :

• RTX 3060 12GB : $330 → Modèles <7B en INT4
• RTX 4070 Ti 12GB : $800 → Modèles <13B en FP16

Production Inference

Modèles 7-13B :

• RTX 4090 24GB : $1,600 → Llama 13B FP16
• L4 24GB : $5,000 → Serverless optimized

Modèles 30-70B :

• A100 40GB : $10,000 → Llama 70B INT4
• L40S 48GB : $8,000 → Mixtral 8x22B INT4

Modèles 100B+ :

• 2× A100 80GB : $30,000 → Full precision
• H100 80GB : $30,000 → Fastest

Fine-tuning

LoRA / QLoRA :

• RTX 4090 24GB : Modèles jusqu’à 13B
• A100 40GB : Modèles jusqu’à 70B avec QLoRA

Full Fine-tuning :

• 4× A100 80GB : Modèles jusqu’à 30B
• 8× A100 80GB : Modèles jusqu’à 70B

FAQ

Pourquoi mes résultats diffèrent de la réalité ?

Les calculs sont des estimations basées sur les formules standard. La VRAM réelle peut varier selon :

• Framework utilisé (PyTorch vs JAX vs TensorFlow)
• Optimisations spécifiques (Flash Attention, kernel custom)
• Overhead système (drivers, CUDA runtime)

Marge de sécurité : Toujours prévoir +20% VRAM minimum.

INT4 vs INT8 : quelle différence ?

• INT8 : -2% qualité, compatible la plupart des tâches
• INT4 : -5% qualité, peut affecter raisonnement complexe

Recommandation : INT4 pour chat/génération simple, INT8 pour code/math.

LoRA vs QLoRA : lequel choisir ?

LoRA :

• Fine-tuning 1% des paramètres
• Qualité ~95-98% du full fine-tuning
• VRAM -60%

QLoRA :

• LoRA + modèle base en INT4
• Qualité ~90-95% du full fine-tuning
• VRAM -75%

Recommandation : QLoRA si VRAM limitée, LoRA si qualité prioritaire.

Combien de VRAM pour entraîner from scratch ?

Formule rapide :

VRAM ≈ Params × 16 bytes (FP16 + Adam)

Exemples:
- GPT-2 1.5B : ~24 GB (1× RTX 4090)
- GPT-3 6B : ~96 GB (2× A100 80GB)
- Llama 7B : ~112 GB (2× A100 80GB)

Training from scratch nécessite 10-20× plus de VRAM que inference.

Autres calculateurs

• Comparateur GPU : Comparez jusqu’à 4 GPU pour trouver le meilleur
• Calculateur de Coût d’API : Estimez vos coûts API avec 11 modèles
• Break-Even Self-Hosting : Calculez la rentabilité du self-hosting vs API
• Simulateur d’Économies ROI : Combinez 5 optimisations et visualisez l’impact

Ressources

Outils

• llm.int8() : Quantization INT8 pour PyTorch
• GPTQ : Quantization INT4 optimisée
• QLoRA : Fine-tuning efficace
• Flash Attention : Réduit VRAM attention de 4×

Articles connexes

• Hardware IA - Guide complet GPU pour IA
• Self-hosting LLM - Coûts infrastructure locale
• Fine-tuning - Guide complet fine-tuning
• Quantization - Comprendre la quantization

Documentation

• HuggingFace PEFT - LoRA/QLoRA
• PyTorch Memory Management
• DeepSpeed - Optimisations training

Astuce : Pour fine-tuner Llama 3.1 70B sur un seul GPU, utilisez QLoRA + gradient checkpointing + batch size 1 → ~48 GB (faisable sur A100 40GB ou 2× RTX 4090).