Mémoire et stockage pour l'IA : Guide complet HBM, VRAM, NVMe en 2026

                        Vitesse          Capacité          Coût/GB
                           ↑                ↓                ↓
    ┌─────────────────────────────────────────────────────────────┐
    │  L1/L2 Cache         │ 1-10 TB/s    │ 10-100 MB     │ N/A   │
    ├─────────────────────────────────────────────────────────────┤
    │  VRAM (HBM3)         │ 3-10 TB/s    │ 24-192 GB     │ 150€  │
    ├─────────────────────────────────────────────────────────────┤
    │  VRAM (GDDR6)        │ 0.5-1 TB/s   │ 12-48 GB      │ 75€   │
    ├─────────────────────────────────────────────────────────────┤
    │  RAM (DDR5)          │ 50-90 GB/s   │ 64-2048 GB    │ 15€   │
    ├─────────────────────────────────────────────────────────────┤
    │  NVMe SSD (Gen5)     │ 10-14 GB/s   │ 1-8 TB        │ 0.10€ │
    ├─────────────────────────────────────────────────────────────┤
    │  SATA SSD            │ 0.5 GB/s     │ 1-8 TB        │ 0.08€ │
    ├─────────────────────────────────────────────────────────────┤
    │  HDD                 │ 0.15 GB/s    │ 4-20 TB       │ 0.02€ │
    └─────────────────────────────────────────────────────────────┘

Vue latérale HBM3 :

    ┌─────────────────────┐
    │   GPU Die           │
    ├─────────────────────┤
    │   Interposer        │
    ├──┬──┬──┬──┬──┬──┬──┤
    │H │H │H │H │H │H │H │ ← 8 stacks HBM3
    │B │B │B │B │B │B │B │   (chaque stack = 12 GB)
    │M │M │M │M │M │M │M │   Total = 96 GB
    │3 │3 │3 │3 │3 │3 │3 │
    └──┴──┴──┴──┴──┴──┴──┘

Interconnexion : Microbumps (25 µm pitch)
Bande passante : 1.2 TB/s par stack
Total : 9.6 TB/s (8 stacks)

Vue du dessus PCB :

    ┌──────┬──────┬──────┬──────┐
    │GDDR6 │GDDR6 │GDDR6 │GDDR6 │
    ├──────┴──────┴──────┴──────┤
    │                            │
    │        GPU Die             │
    │                            │
    ├──────┬──────┬──────┬──────┤
    │GDDR6 │GDDR6 │GDDR6 │GDDR6 │
    └──────┴──────┴──────┴──────┘

Interconnexion : PCB traces (plusieurs cm)
Bande passante : 64 GB/s par puce (×12-16 puces)
Total : 768-1008 GB/s

VRAM_needed = (
    Model_params × Bytes_per_param × Model_multiplier +
    Batch_size × Seq_length × Hidden_size × Layers × Activation_multiplier
)

Où :
- Model_params : Nombre de paramètres (7B, 13B, 70B)
- Bytes_per_param : 4 (FP32), 2 (FP16/BF16), 1 (INT8), 0.5 (INT4)
- Model_multiplier : 1.0 (inférence), 1.5 (LoRA), 4.0 (full fine-tuning)
- Activation_multiplier : Dépend de l'architecture (1.0-2.0)

# Paramètres du modèle
params = 7_000_000_000  # 7B
bytes_per_param = 2      # FP16
overhead = 1.2           # Inférence (activations, KV cache)

# Calcul
model_vram = params × bytes_per_param × overhead
model_vram = 7B × 2 × 1.2 = 16.8 GB

# Activations (batch_size=1, seq_len=2048)
batch_size = 1
seq_length = 2048
hidden_size = 4096
layers = 32
activation_size = batch_size × seq_length × hidden_size × layers × 2  # FP16
activation_gb = activation_size / 1e9 = 0.54 GB

# KV Cache (important pour génération)
kv_cache = batch_size × seq_length × layers × hidden_size × 2 × 2  # K et V
kv_cache_gb = kv_cache / 1e9 = 1.08 GB

# Total
total_vram = 16.8 + 0.54 + 1.08 = 18.42 GB

# GPU nécessaire : RTX 4090 (24 GB) ✅

# Modèle base
base_vram = 13B × 2 × 1.2 = 31.2 GB

# LoRA adapters (rank=64, alpha=128)
# Seulement ~1% des paramètres entraînés
lora_params = 13B × 0.01 = 130M
lora_vram = 130M × 2 × 4 = 1.04 GB  # × 4 pour gradients + optimizer

# Activations avec gradient checkpointing
batch_size = 4
activation_multiplier = 0.4  # Checkpointing réduit de 60%
activation_vram = 4 × 2048 × 4096 × 32 × 2 × 0.4 / 1e9 = 3.4 GB

# Total
total_vram = 31.2 + 1.04 + 3.4 = 35.64 GB

# GPU nécessaire : A100 40GB ✅
# Ou : 2× RTX 4090 (48 GB total) ✅

# Modèle
model_vram = 70B × 2 = 140 GB

# Gradients (même taille que modèle)
gradient_vram = 140 GB

# Optimizer states (Adam = 2× modèle)
optimizer_vram = 140 GB × 2 = 280 GB

# Activations (batch=8, avec checkpointing)
activation_vram = 8 × 2048 × 8192 × 80 × 2 × 0.4 / 1e9 = 17 GB

# Total
total_vram = 140 + 140 + 280 + 17 = 577 GB

# GPU nécessaire : 8× A100 80GB (640 GB) ✅
# Avec DeepSpeed ZeRO-3 + offloading : 4× A100 80GB ✅

# Configuration DeepSpeed avec offload RAM
ds_config = {
    "train_batch_size": 64,
    "train_micro_batch_size_per_gpu": 2,
    "gradient_accumulation_steps": 8,
    "fp16": {"enabled": True},
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
            "device": "cpu",  # Optimizer states en RAM
            "pin_memory": True  # Accès plus rapide
        }
    }
}

# Avant offload : LLaMA 13B
# - VRAM : 31.2 (model) + 31.2 (gradients) + 62.4 (optimizer) = 124.8 GB
# - GPU nécessaire : 4× A100 40GB (160 GB)

# Avec offload optimizer :
# - VRAM : 31.2 (model) + 31.2 (gradients) = 62.4 GB
# - RAM : 62.4 GB (optimizer offloaded)
# - GPU nécessaire : 2× A100 40GB (80 GB) ✅
# - Perte de performance : ~15% (transferts RAM ↔ VRAM)

# Dataset : ImageNet (150 GB, 1.4M images)
# Batch size : 256 images
# Images/epoch : 1 400 000

# Calcul temps de lecture

# SATA SSD (550 MB/s)
read_time_sata = 150 GB / 0.55 GB/s = 273 secondes = 4.5 minutes

# NVMe Gen4 (7 GB/s)
read_time_nvme = 150 GB / 7 GB/s = 21 secondes

# Accélération : 13× plus rapide avec NVMe Gen4

Fichier A divisé en 4 morceaux :

┌──────┬──────┬──────┬──────┐
│ A1   │ A2   │ A3   │ A4   │
└──┬───┴──┬───┴──┬───┴──┬───┘
   │      │      │      │
   v      v      v      v
┌──────┬──────┬──────┬──────┐
│NVMe 1│NVMe 2│NVMe 3│NVMe 4│
└──────┴──────┴──────┴──────┘

Lecture parallèle : 4× plus rapide

# Multiplication matricielle naïve (cache-unfriendly)
def matmul_naive(A, B):
    C = np.zeros((M, N))
    for i in range(M):
        for j in range(N):
            for k in range(K):
                C[i,j] += A[i,k] * B[k,j]  # Accès mémoire chaotique
    return C

# Multiplication tiled (cache-friendly)
def matmul_tiled(A, B, tile_size=64):
    C = np.zeros((M, N))
    for i in range(0, M, tile_size):
        for j in range(0, N, tile_size):
            for k in range(0, K, tile_size):
                # Charger tuile en L1 cache
                tile_A = A[i:i+tile_size, k:k+tile_size]
                tile_B = B[k:k+tile_size, j:j+tile_size]
                # Calcul réutilise données en cache
                C[i:i+tile_size, j:j+tile_size] += tile_A @ tile_B
    return C

# Performance sur H100 :
# Naïve : 45 TFLOPS (2% du pic théorique)
# Tiled : 1200 TFLOPS (60% du pic théorique)
# Amélioration : 27× plus rapide

import torch

# Allocation standard (copie explicite)
x_cpu = torch.randn(10000, 10000)
x_gpu = x_cpu.to('cuda')  # Copie RAM → VRAM

# Unified Memory (migration automatique)
x_unified = torch.randn(10000, 10000, device='cuda',
                       memory_format=torch.cuda.memory_format.pinned)

# Avantages :
# - Pas de copie explicite
# - Migration automatique page-by-page
# - Oversubscription : utiliser RAM si VRAM pleine

# LLaMA 70B (168 GB) sur RTX 4090 (24 GB VRAM)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-70b-hf",
    device_map="auto",
    offload_folder="offload",  # Utilise RAM + NVMe
    offload_state_dict=True
)

# Comportement :
# - Couches utilisées → VRAM (24 GB)
# - Couches inactives → RAM (128 GB)
# - Poids très froids → NVMe (500 GB)
# - Migration automatique selon besoin

# Performance :
# - Inférence : 2-5 tokens/sec (vs 95 tok/s full VRAM)
# - Économie : 144 GB VRAM (6× moins de GPUs)
# - Trade-off : 20-50× plus lent

# LLaMA 2 70B dans différentes précisions

# FP32 (baseline)
vram_fp32 = 70B × 4 bytes = 280 GB

# FP16 / BF16
vram_fp16 = 70B × 2 bytes = 140 GB  (économie 50%)

# INT8
vram_int8 = 70B × 1 byte = 70 GB  (économie 75%)

# INT4
vram_int4 = 70B × 0.5 bytes = 35 GB  (économie 87.5%)

# GPU nécessaire :
# FP32 : 4× A100 80GB (320 GB)
# FP16 : 2× A100 80GB (160 GB)
# INT8 : 1× A100 80GB ✅
# INT4 : 1× RTX 6000 48GB ✅

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

# Quantization INT8
quantization_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0,  # Seuil activation
    llm_int8_skip_modules=["lm_head"]  # Garder certaines couches FP16
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-13b-hf",
    quantization_config=quantization_config,
    device_map="auto"
)

# VRAM : 13B × 1 byte = 13 GB (vs 26 GB FP16)
# Qualité : 98-99% de l'original
# Speed : Légèrement plus lent (déquantization à la volée)

from torch.quantization import quantize_dynamic, prepare_qat

# Entraîner avec simulation quantization
model_qat = prepare_qat(model, inplace=False)

for epoch in range(num_epochs):
    for batch in dataloader:
        # Forward en FP32 simulant INT8
        outputs = model_qat(batch)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

# Convertir en INT8 réel après training
model_int8 = quantize_dynamic(model_qat, {nn.Linear}, dtype=torch.qint8)

# Qualité : 99-100% de l'original (meilleur que PTQ)
# Coût : Nécessite re-training

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

# Configuration GPTQ (INT4)
quantize_config = BaseQuantizeConfig(
    bits=4,  # 4-bit quantization
    group_size=128,  # Groupes de 128 poids
    desc_act=True  # Ordre activation descendant
)

# Quantizer avec calibration dataset
model = AutoGPTQForCausalLM.from_pretrained(
    "meta-llama/Llama-2-70b-hf",
    quantize_config=quantize_config
)

model.quantize(calibration_dataset)

# VRAM : 70B × 0.5 bytes = 35 GB
# Qualité : 95-97% de l'original (meilleur que naïve INT4)
# Vitesse : 2-3× plus rapide que FP16 (moins de transferts mémoire)

GPU : 1× RTX 4070 Ti 12GB     900€
RAM : 64 GB DDR5-5600         250€
SSD : 2 TB NVMe Gen4          180€
Total :                       1330€

Capacités :
- Inférence LLaMA 13B INT8 ✅
- Fine-tuning LLaMA 7B LoRA ✅
- Datasets < 500 GB ✅

GPU : 1× RTX 4090 24GB        1800€
RAM : 128 GB DDR5-5600         500€
SSD : 4 TB NVMe Gen4 RAID 0    360€
Total :                       2660€

Capacités :
- Inférence LLaMA 34B INT4 ✅
- Fine-tuning LLaMA 13B LoRA ✅
- Datasets < 2 TB ✅

GPU : 2× RTX 6000 Ada 48GB    14 000€
RAM : 256 GB DDR5-5600         1 200€
SSD : 8 TB NVMe Gen4 RAID 10   1 440€
Total :                       16 640€

Capacités :
- Fine-tuning LLaMA 70B INT8 ✅
- Training distribué ✅
- Datasets < 8 TB ✅

GPU : 8× A100 80GB            144 000€
RAM : 1 TB DDR5-4800 ECC       4 800€
SSD : 32 TB NVMe Gen4 RAID 10  5 760€
NAS : 200 TB NVMe-oF          50 000€
Total :                      204 560€

Capacités :
- Training GPT-3 175B ✅
- Datasets < 200 TB ✅
- Multi-utilisateurs ✅

from torch.utils.checkpoint import checkpoint

class TransformerBlock(nn.Module):
    def forward(self, x):
        # Sans checkpointing : stocke activations (VRAM++)
        return self.attention(self.norm1(x)) + self.ffn(self.norm2(x))

    def forward_checkpoint(self, x):
        # Avec checkpointing : recalcule pendant backward (VRAM--)
        return checkpoint(self._forward, x)

# Impact :
# LLaMA 13B sans checkpointing : 45 GB VRAM
# LLaMA 13B avec checkpointing : 18 GB VRAM (-60%)
# Coût : +20% temps training (recalculs)

# Attention standard
def standard_attention(Q, K, V):
    # seq_len = 4096, hidden = 4096
    scores = Q @ K.T  # (4096, 4096) → 67 MB en FP16
    attn = softmax(scores / sqrt(d_k))
    return attn @ V

# Flash Attention
from flash_attn import flash_attn_func

def flash_attention(Q, K, V):
    # Calcul par blocs (ex: 64×64)
    # Ne matérialise jamais la matrice complète
    return flash_attn_func(Q, K, V)

# Impact :
# Standard attention (seq=4096) : 67 MB par layer
# Flash attention : 4 MB par layer (-94%)
# Pour 32 layers : économie 2 GB VRAM
# Bonus : 2-4× plus rapide

import torch
from accelerate import cpu_offload

# Modèle trop grand pour VRAM
model = LargeModel()  # 50 GB

# Offload automatique
model = cpu_offload(
    model,
    execution_device="cuda:0",
    offload_buffers=True
)

# Comportement :
# - Couche active → VRAM
# - Couche terminée → RAM
# - VRAM utilisée : 5-10 GB (seulement 1-2 couches)
# - Performance : 5-10× plus lent que full VRAM

from torch.utils.data import DataLoader

# DataLoader standard
loader = DataLoader(
    dataset,
    batch_size=32,
    num_workers=4  # Préparation CPU parallèle
)

# DataLoader avec pinned memory (plus rapide)
loader = DataLoader(
    dataset,
    batch_size=32,
    num_workers=4,
    pin_memory=True,  # Mémoire non-swappable
    prefetch_factor=4  # Prépare 4 batches en avance
)

# Impact :
# Standard : GPU idle 15% du temps (attente données)
# Pinned + prefetch : GPU idle 2% du temps
# Amélioration : +13% throughput

# Monitoring temps réel
nvidia-smi dmon -s mu

# Résultat :
# gpu   pwr  gtemp  mtemp  fb    sm
#   0    85     65     -   18432  45
#   1   120     72     -   24000  98

# fb : VRAM utilisée (MB)
# sm : GPU utilization (%)

import torch

# Réserver VRAM au démarrage (évite fragmentation)
torch.cuda.empty_cache()

# Allocations
model = MyModel().cuda()
print(f"Model: {torch.cuda.memory_allocated() / 1e9:.2f} GB")

optimizer = torch.optim.Adam(model.parameters())
print(f"Optimizer: {torch.cuda.memory_allocated() / 1e9:.2f} GB")

# Training
for batch in dataloader:
    outputs = model(batch)
    loss = criterion(outputs)
    loss.backward()

    # Snapshot mémoire
    print(f"Peak: {torch.cuda.max_memory_allocated() / 1e9:.2f} GB")

    optimizer.step()
    optimizer.zero_grad()

# Résumé
print(torch.cuda.memory_summary())

# Linux
free -h

# Résultat :
#               total        used        free      shared  buff/cache
# Mem:           125Gi        42Gi        68Gi       1.2Gi        15Gi
# Swap:           16Gi         0Gi        16Gi

# Monitoring continu
watch -n 1 free -h