GPU pour l'IA : Guide complet NVIDIA vs AMD en 2026

# Multiplication de matrices A (1000×1000) × B (1000×1000)

# CPU : Calcule chaque élément séquentiellement
for i in range(1000):
    for j in range(1000):
        C[i][j] = sum(A[i][k] * B[k][j] for k in range(1000))
# Temps : ~5 secondes

# GPU : Calcule tous les éléments en parallèle
C = A @ B  # PyTorch avec CUDA
# Temps : ~0.001 secondes (5000× plus rapide !)

import torch
import time

# Matrice 8192×8192 (simulation d'une couche de transformer)
A = torch.randn(8192, 8192, dtype=torch.float16, device='cuda')
B = torch.randn(8192, 8192, dtype=torch.float16, device='cuda')

# Sans Tensor Cores (FP32)
A_fp32 = A.to(torch.float32)
B_fp32 = B.to(torch.float32)
start = time.time()
C_fp32 = A_fp32 @ B_fp32
torch.cuda.synchronize()
print(f"FP32 : {time.time() - start:.3f}s")

# Avec Tensor Cores (FP16)
start = time.time()
C_fp16 = A @ B
torch.cuda.synchronize()
print(f"FP16 (Tensor Cores) : {time.time() - start:.3f}s")

# Résultat sur RTX 4090 :
# FP32 : 0.145s
# FP16 (Tensor Cores) : 0.018s
# Accélération : 8× plus rapide

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
import torch

# Charger le modèle en 4-bit (économise VRAM)
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    load_in_4bit=True,
    device_map="auto"
)

# Configuration LoRA
lora_config = LoraConfig(
    r=16,  # Rang des matrices LoRA
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Résultat : trainable params: 8.4M (0.12% du modèle)
# VRAM utilisée : ~12 GB (reste 4 GB pour batch)

Modèle : 7B paramètres
Précision : FP16 (2 bytes/param)
Overhead optimizer : 20%

VRAM = 7B × 2 bytes × 1.2 = 16.8 GB
Résultat : Impossible sur 12 GB sans optimisation

Solution : Quantization INT8
VRAM = 7B × 1 byte × 1.2 = 8.4 GB
Résultat : ✅ Fonctionne avec 12 GB (reste 3.6 GB pour batch)

from transformers import AutoModelForCausalLM, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model

# Charger modèle en 16-bit
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-13b-hf",
    torch_dtype=torch.float16,
    device_map="auto"
)

# LoRA configuration
lora_config = LoraConfig(
    r=64,  # Rang plus élevé pour meilleure qualité
    lora_alpha=128,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.1
)

model = get_peft_model(model, lora_config)

# Training arguments
training_args = TrainingArguments(
    output_dir="./llama-2-13b-finetuned",
    per_device_train_batch_size=4,  # Possible avec 24 GB
    gradient_accumulation_steps=4,  # Batch effectif = 16
    num_train_epochs=3,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_steps=100
)

# VRAM utilisée :
# Modèle : 13B × 2 bytes = 26 GB (impossible sans optimisation)
# Avec LoRA : trainable params ~42M (0.3% du modèle)
# VRAM réelle : ~18 GB (reste 6 GB pour batch size 4)

Modèle : 34B paramètres
Précision : FP16

VRAM = 34B × 2 bytes × 1.2 = 81.6 GB
Résultat : ❌ Impossible sur 48 GB

Solution : Quantization INT8
VRAM = 34B × 1 byte × 1.2 = 40.8 GB
Résultat : ✅ Fonctionne sur 48 GB (reste 7 GB)

Ou multi-GPU : 2× RTX 6000 Ada = 96 GB VRAM
CodeLlama 34B en FP16 : ✅ Possible

# Configuration : 8× A100 80GB = 640 GB VRAM totale
# Objectif : Fine-tuner LLaMA 2 70B

import deepspeed
from transformers import AutoModelForCausalLM

# DeepSpeed ZeRO-3 : partitionne le modèle sur tous les GPUs
ds_config = {
    "train_batch_size": 128,
    "train_micro_batch_size_per_gpu": 2,
    "gradient_accumulation_steps": 8,
    "fp16": {
        "enabled": True
    },
    "zero_optimization": {
        "stage": 3,  # Partitionne tout (params, gradients, optimizer)
        "offload_optimizer": {
            "device": "cpu"  # Offload optimizer sur RAM CPU
        },
        "offload_param": {
            "device": "nvme"  # Offload params sur NVMe SSD
        }
    }
}

# Charger modèle
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-70b-hf")

# Initialiser DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    config=ds_config
)

# VRAM par GPU :
# Sans optimisation : 70B × 2 bytes = 140 GB → Impossible
# Avec ZeRO-3 + offload : ~35 GB par GPU → ✅ Fonctionne sur 80 GB
# Performance : 2.5 heures pour 1 epoch sur 50k exemples

Sur H100 80GB :
Mixtral 8×7B en FP16 : 47B × 2 bytes = 94 GB
Résultat : ⚠️ Nécessite 2× H100 (70k€)

Sur MI300X 192GB :
Mixtral 8×7B en FP16 : 94 GB
Résultat : ✅ Tient sur 1× MI300X (15k€)
Économie : 55k€ (79%)

# Installation en une ligne
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# Vérification
python -c "import torch; print(torch.cuda.is_available())"
# Output : True

# Test performance
python -c "
import torch
import time
A = torch.randn(10000, 10000, device='cuda')
start = time.time()
B = A @ A
torch.cuda.synchronize()
print(f'CUDA matmul : {time.time()-start:.3f}s')
"
# Output : CUDA matmul : 0.012s

# Installation (ROCm 6.0)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0

# Vérification
python -c "import torch; print(torch.cuda.is_available())"
# Output : True (ROCm utilise l'API CUDA pour compatibilité)

# Test performance
python -c "
import torch
import time
A = torch.randn(10000, 10000, device='cuda')
start = time.time()
B = A @ A
torch.cuda.synchronize()
print(f'ROCm matmul : {time.time()-start:.3f}s')
"
# Output : ROCm matmul : 0.018s (1.5× plus lent que CUDA sur cet exemple)

VRAM = (Paramètres × Bytes_per_param × Overhead)

Où :
- Paramètres : nombre de paramètres du modèle (ex: 7B, 13B, 70B)
- Bytes_per_param : 4 (FP32), 2 (FP16/BF16), 1 (INT8), 0.5 (INT4)
- Overhead : 1.2 (inférence), 3-4 (fine-tuning avec gradients)

# Précision FP16
Paramètres = 7B
Bytes = 2 (FP16)
Overhead = 1.2

VRAM = 7B × 2 × 1.2 = 16.8 GB

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

# Modèle base en FP16
Base_VRAM = 13B × 2 × 1.2 = 31.2 GB

# LoRA ajoute seulement 1-2% de paramètres
LoRA_params = 13B × 0.015 = 195M
LoRA_VRAM = 195M × 2 × 4 = 1.56 GB (avec gradients)

# Overhead batch + activations
Batch_VRAM = 4 GB (pour batch_size=4)

Total_VRAM = 31.2 + 1.56 + 4 = 36.76 GB

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

# Tous les paramètres entraînés
Paramètres = 70B
Bytes = 2 (FP16)
Overhead = 4 (modèle + gradients + optimizer states)

VRAM = 70B × 2 × 4 = 560 GB

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

# Génération de 500 tokens (réponse longue)

Sur RTX 4090 (82 tok/s) :
Temps = 500 / 82 = 6.1 secondes

Sur H100 (180 tok/s) :
Temps = 500 / 180 = 2.8 secondes

Différence : 2.2× plus rapide sur H100

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for batch in dataloader:
    optimizer.zero_grad()

    # Forward pass en FP16 (2× plus rapide)
    with autocast():
        outputs = model(batch)
        loss = criterion(outputs, targets)

    # Backward pass avec scaling (évite underflow)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

# Résultat : 2× plus rapide, même qualité

# Simuler batch_size=32 avec seulement 8 GB VRAM

accumulation_steps = 8  # 4 × 8 = 32 batch effectif
optimizer.zero_grad()

for i, batch in enumerate(dataloader):
    outputs = model(batch)
    loss = criterion(outputs, targets)

    # Normaliser la loss
    loss = loss / accumulation_steps
    loss.backward()

    # Optimizer step tous les 8 batches
    if (i + 1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

# Résultat : Batch size 32 avec VRAM de batch size 4

from torch.utils.checkpoint import checkpoint

class TransformerBlock(nn.Module):
    def forward(self, x):
        # Recalculer activations au lieu de les stocker
        return checkpoint(self._forward, x)

    def _forward(self, x):
        # Couches du transformer
        return self.attention(x) + self.ffn(x)

# Résultat : VRAM divisée par 2-3, temps +20%
# Exemple : LLaMA 13B passe de 31 GB à 12 GB

from flash_attn import flash_attn_func

# Attention standard (O(n²) mémoire)
def standard_attention(Q, K, V):
    scores = Q @ K.T / sqrt(d_k)  # (seq_len, seq_len) → VRAM intensive
    attn = softmax(scores)
    return attn @ V

# FlashAttention (O(n) mémoire)
def flash_attention(Q, K, V):
    # Calcul par blocs, évite de stocker la matrice d'attention
    return flash_attn_func(Q, K, V)

# Résultat : 2-4× plus rapide, 5-10× moins de VRAM
# Exemple : Llama 13B avec seq_len=4096
# Standard : 28 GB VRAM, 450 tok/s
# Flash : 18 GB VRAM, 1200 tok/s

import torch

# Modèle original (FP16)
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
print(f"VRAM : {torch.cuda.memory_allocated() / 1e9:.1f} GB")
# Output : VRAM : 13.5 GB

# Quantization INT8 (bitsandbytes)
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0
)

model_int8 = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=quantization_config,
    device_map="auto"
)
print(f"VRAM : {torch.cuda.memory_allocated() / 1e9:.1f} GB")
# Output : VRAM : 6.8 GB (2× moins !)

# Perte de qualité : < 1% sur la plupart des benchmarks

import torch.nn as nn
from torch.nn.parallel import DataParallel

# Modèle sur GPU 0
model = MyModel()

# Répliquer sur 4 GPUs
model = DataParallel(model, device_ids=[0, 1, 2, 3])

# Training automatique sur 4 GPUs
for batch in dataloader:
    # Batch divisé en 4 sous-batches automatiquement
    outputs = model(batch)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

# Avantages : Simple, transparent
# Limitations : Chaque GPU doit contenir le modèle complet

import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# Initialiser processus distribué
dist.init_process_group(backend='nccl')
local_rank = int(os.environ['LOCAL_RANK'])

# Modèle sur GPU local
model = MyModel().to(local_rank)
model = DDP(model, device_ids=[local_rank])

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

# Avantages : 2-3× plus rapide que DP, scaling efficace
# Limitations : Setup plus complexe

# 4 GPUs sur 1 machine
torchrun --nproc_per_node=4 train.py

# 16 GPUs sur 2 machines
torchrun --nproc_per_node=8 --nnodes=2 --node_rank=0 --master_addr="192.168.1.1" train.py

# Exemple : GPT avec 48 couches sur 4 GPUs

class PipelinedGPT(nn.Module):
    def __init__(self):
        super().__init__()
        # GPU 0 : Couches 0-11
        self.layers_0_11 = nn.Sequential(*layers[:12]).to('cuda:0')
        # GPU 1 : Couches 12-23
        self.layers_12_23 = nn.Sequential(*layers[12:24]).to('cuda:1')
        # GPU 2 : Couches 24-35
        self.layers_24_35 = nn.Sequential(*layers[24:36]).to('cuda:2')
        # GPU 3 : Couches 36-47
        self.layers_36_47 = nn.Sequential(*layers[36:]).to('cuda:3')

    def forward(self, x):
        x = self.layers_0_11(x)
        x = x.to('cuda:1')
        x = self.layers_12_23(x)
        x = x.to('cuda:2')
        x = self.layers_24_35(x)
        x = x.to('cuda:3')
        x = self.layers_36_47(x)
        return x

# Avantages : Permet de charger des modèles énormes
# Limitations : Pipeline bubbles (inefficacité), complexité

import deepspeed

# Configuration ZeRO Stage 3 (partitionne tout)
ds_config = {
    "train_batch_size": 64,
    "train_micro_batch_size_per_gpu": 2,
    "gradient_accumulation_steps": 8,
    "fp16": {"enabled": True},
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "nvme"}
    }
}

# Initialiser DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    config=ds_config
)

# Training
for batch in dataloader:
    loss = model_engine(batch)
    model_engine.backward(loss)
    model_engine.step()

# Résultat : LLaMA 70B sur 4× A100 40GB (160 GB total)
# Sans ZeRO : Impossible (nécessite 280 GB)
# Avec ZeRO-3 : ✅ Fonctionne (~35 GB par GPU)

# Benchmark : Transfert de 10 GB entre 2 GPUs

# PCIe 4.0
Temps = 10 GB / 64 GB/s = 156 ms

# NVLink 3.0
Temps = 10 GB / 600 GB/s = 16.7 ms

# Accélération : 9.3× plus rapide avec NVLink

ROI = Prix GPU / (Coût cloud par heure × Heures d'utilisation par mois)

Exemple : RTX 4090 (1800€) vs A100 cloud (2.5€/h)
ROI = 1800€ / (2.5€ × 100h/mois) = 7.2 mois

Si utilisation > 100h/mois → Acheter GPU local
Si utilisation < 100h/mois → Utiliser cloud

# Monitoring en temps réel
watch -n 1 nvidia-smi

# Résultat :
# +-----------------------------------------------------------------------------+
# | NVIDIA-SMI 535.129.03   Driver Version: 535.129.03   CUDA Version: 12.2   |
# |-------------------------------+----------------------+----------------------+
# | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
# | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
# |===============================+======================+======================|
# |   0  NVIDIA RTX 4090     Off  | 00000000:01:00.0 Off |                  Off |
# | 45%   68C    P2   380W / 450W |  18432MiB / 24564MiB |     98%      Default |
# +-------------------------------+----------------------+----------------------+

# Explication :
# - Temp : 68°C (bon, max recommandé 85°C)
# - Power : 380W / 450W (84% TDP)
# - Memory : 18.4 GB / 24.5 GB (75% utilisé)
# - GPU Util : 98% (excellent !)

# Monitoring AMD
watch -n 1 rocm-smi

# Résultat similaire à nvidia-smi

from torch.profiler import profile, ProfilerActivity

with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA]) as prof:
    for _ in range(10):
        outputs = model(batch)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

# Afficher résultats
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

# Résultat :
# ---------------------------------  ------------  ------------  ------------
#                              Name    CPU total     CUDA total  CUDA memory
# ---------------------------------  ------------  ------------  ------------
#                   model_inference       152.45ms       143.21ms      1.2 GB
#                    loss_backward        89.32ms        85.44ms      0.8 GB
#                  optimizer_step        12.45ms        10.23ms      0.1 GB
# ---------------------------------  ------------  ------------  ------------

import torch
import time

# Code inefficace (GPU util ~30%)
for batch in dataloader:
    batch = batch.to('cuda')  # Transfert CPU → GPU (bloque GPU)
    outputs = model(batch)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

# Code optimisé (GPU util ~95%)
for batch in dataloader:
    batch = batch.to('cuda', non_blocking=True)  # Transfert asynchrone
    outputs = model(batch)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

# Trouver batch size optimal
batch_size = 1
while True:
    try:
        batch = torch.randn(batch_size, 3, 224, 224, device='cuda')
        outputs = model(batch)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

        print(f"Batch size {batch_size} : OK ({torch.cuda.memory_allocated() / 1e9:.1f} GB)")
        batch_size += 1
    except RuntimeError as e:
        if "out of memory" in str(e):
            print(f"Batch size max : {batch_size - 1}")
            break

# Résultat sur RTX 4090 :
# Batch size 64 : OK (22.3 GB)
# Batch size 65 : OOM
# Batch size optimal : 64 (91% VRAM utilisée)

import time

start = time.time()
samples_processed = 0

for batch in dataloader:
    outputs = model(batch)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

    samples_processed += batch.size(0)

    if samples_processed >= 1000:
        break

elapsed = time.time() - start
throughput = samples_processed / elapsed

print(f"Throughput : {throughput:.1f} samples/sec")

# RTX 4090 : 450 samples/sec
# A100 40GB : 520 samples/sec
# H100 80GB : 980 samples/sec