CUDA out of memory : causes, correctifs, et quand passer à un GPU avec plus de VRAM

Ce que veut dire l’erreur

torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate … veut dire que PyTorch demande plus de mémoire que ce qui reste libre sur la carte. Cette mémoire sert aux poids du modèle, aux gradients, à l’état de l’optimiseur et aux activations, qui grandissent avec la taille du batch et la longueur des séquences.

Avant de corriger, mesure : la ligne « pic » montre combien ton entraînement demande vraiment.

import torch

print(torch.cuda.get_device_name(0))
print(f"total : {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
print(f"pic   : {torch.cuda.max_memory_allocated() / 1e9:.1f} GB")
print(torch.cuda.memory_summary(abbreviated=True))

Les correctifs, dans l’ordre

1. 1.Réduis la taille du batch

   Divise batch_size par deux jusqu’à ce que l’erreur disparaisse. Pour garder le même batch effectif, accumule les gradients sur plusieurs pas.

   accumulation_steps = 4  # batch effectif = batch_size x 4
   
   optimizer.zero_grad()
   for step, (inputs, targets) in enumerate(loader):
       loss = criterion(model(inputs), targets) / accumulation_steps
       loss.backward()
       if (step + 1) % accumulation_steps == 0:
           optimizer.step()
           optimizer.zero_grad()

2. 2.Passe en précision mixte

   Les activations en 16 bits prennent environ la moitié de la mémoire du 32 bits. torch.autocast choisit la précision opération par opération.

   import torch
   
   # bf16 si la carte le permet, sinon fp16 avec un GradScaler
   dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
   scaler = torch.amp.GradScaler("cuda", enabled=(dtype == torch.float16))
   
   for inputs, targets in loader:
       optimizer.zero_grad()
       with torch.autocast(device_type="cuda", dtype=dtype):
           loss = criterion(model(inputs), targets)
       scaler.scale(loss).backward()
       scaler.step(optimizer)
       scaler.update()

3. 3.Active le gradient checkpointing

   Les activations intermédiaires sont recalculées pendant la rétropropagation au lieu d’être gardées en mémoire : moins de VRAM, un peu plus de calcul.

   # Modèle Hugging Face Transformers
   model.gradient_checkpointing_enable()
   
   # Module PyTorch maison
   from torch.utils.checkpoint import checkpoint
   
   def forward(self, x):
       x = checkpoint(self.block1, x, use_reentrant=False)
       return self.block2(x)

4. 4.Quantifie le modèle

   Pour l’inférence ou un ajustement QLoRA, charger les poids en 4 bits divise leur taille par quatre par rapport au 16 bits.

   # pip install transformers accelerate bitsandbytes
   import torch
   from transformers import AutoModelForCausalLM, BitsAndBytesConfig
   
   quantization = BitsAndBytesConfig(
       load_in_4bit=True,
       bnb_4bit_quant_type="nf4",
       bnb_4bit_compute_dtype=torch.bfloat16,
   )
   model = AutoModelForCausalLM.from_pretrained(
       "Qwen/Qwen2.5-7B-Instruct",
       quantization_config=quantization,
       device_map="auto",
   )

5. 5.En inférence, coupe le calcul des gradients

   Sans torch.inference_mode(), PyTorch garde ce qu’il faut pour une rétropropagation qui n’arrivera jamais.

   model.eval()
   with torch.inference_mode():
       outputs = model(inputs)

6. 6.Limite la fragmentation

   Si le message indique beaucoup de mémoire « reserved but unallocated », laisse l’allocateur agrandir ses segments.

   PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True python train.py

Combien de VRAM prennent les poids d’un modèle

Exemple : un modèle de 7 milliards de paramètres occupe 14 Go en 16 bits, 7 Go en 8 bits et 3,5 Go en 4 bits, avant les activations et le reste.

Quand passer à un GPU avec plus de VRAM

Si ton modèle ne tient toujours pas après ces correctifs, ou si la quantification dégrade trop les résultats, il te faut plus de mémoire. Chez GPU Cloud, la plus petite carte a 48 Go, et un serveur peut aller jusqu’à 8 GPU, soit 768 Go au total (8 × NVIDIA RTX PRO 6000).

Avec plusieurs GPU, le modèle doit être réparti entre les cartes (par exemple device_map="auto" avec Transformers, ou FSDP pour l’entraînement). Le guide pour lancer ton script sur un GPU montre comment copier ton projet et lancer l’entraînement sur le serveur.

Ce qu’il faut savoir avant de lancer

• La facturation se fait à l’heure, au tarif horaire du serveur, à partir d’un crédit prépayé. Il n’y a pas de facturation à la minute, et la première heure est prélevée au déploiement.
• Un serveur arrêté reste facturé au plein tarif horaire. Pour payer moins, hiberne-le (0,02 $ par heure (environ 14,60 $ par mois), disque conservé) ou supprime-le. Une machine Spot ne s’hiberne pas : supprime-la quand tu as fini.
• La recharge minimale est de 25,00 $ CA, payée par carte de crédit.
• Les serveurs et leurs disques restent au Canada (région canada-montreal, à Montréal). Les renseignements du compte (identité, facturation, courriels) peuvent être traités hors du Québec, comme l’explique la politique de confidentialité.

Questions fréquentes