# Pourquoi un modèle peut-il entrer sur votre machine sans qu’il soit possible de l’entraîner?

Date: 2026-07-16 · Author: Robert Scales · https://guidetoartificialintelligence.com/fr/apprendre/budget-memoire-entrer-ou-entrainer-modele/

**Answer:** Exécuter un modèle exige surtout de la place pour ses poids, alors que l’entraîner exige aussi un gradient par poids, deux copies de plus pour l’optimiseur et toutes les activations à conserver pour la passe arrière. Mesuré sur un modèle de 135 millions de paramètres, l’entraînement complet a pris 5,1 fois la mémoire de l’exécution à taille de lot égale, et un adaptateur LoRA a réduit le pic des deux tiers.

La règle habituelle vous dit si un modèle va entrer : paramètres multipliés par les octets par poids, comme l’explique [cet article sur le calcul de la mémoire](/fr/apprendre/memoire-modele-ia-calcul/). Ce chiffre répond à la question « puis-je l’exécuter? ». L’entraînement est une tout autre facture. Bien des gens s’en rendent compte quand une exécution qui semblait sûre plante à sa première étape.

Ce projet mesure cette facture avec un petit modèle, [SmolLM2-135M-Instruct](https://huggingface.co/HuggingFaceTB/SmolLM2-135M-Instruct), qui compte 134 515 008 paramètres et une licence Apache 2.0. Chaque ligne ci-dessous a été exécutée dans un nouveau processus sur le processeur, en nombres de 32 bits sauf indication contraire, et a lu le pic de mémoire donné par le système d’exploitation. C’est donc un vrai pic et non une estimation. Les pics incluent un peu de surcoût de chargement, et les 244 Mo qu’occupaient Python et les bibliothèques avant tout modèle ont déjà été soustraits. Le script est `07_memory_budget.py`.

## Où va la mémoire

| Partie | Taille pour ce modèle | Comment elle augmente |
|---|---|---|
| Poids | 538 Mo (calculé : 134,5 millions × 4 octets) | Avec les paramètres et la précision |
| Gradients, un par poids | 538 Mo (calculé) | Avec les paramètres entraînables |
| État de l’optimiseur, deux par poids pour [Adam](https://arxiv.org/abs/1412.6980) | 1 076 Mo (calculé) | Avec les paramètres entraînables |
| Activations gardées pour la passe arrière | Selon l’exécution | Avec lot × longueur × couches |

L’exécution exige la première ligne et une plus petite part de la dernière. L’entraînement exige les quatre. Avant même de traiter un seul exemple, l’entraînement coûte donc déjà quatre fois les poids. Ces trois lignes fixes totalisent 2 152 Mo.

## Ce qui a été mesuré

La longueur des séquences est de 256 jetons, sauf indication contraire. Mesuré ici sur un Apple M5 Max avec 64 Go, PyTorch 2.15 et Transformers 5.22.

| Travail | Lot | Pic au-dessus de la base |
|---|---|---|
| Chargement seulement | | 944 Mo |
| Exécution, sans entraînement | 1 | 943 Mo |
| Exécution, sans entraînement | 8 | 1 269 Mo |
| Entraînement complet | 1 | 3 093 Mo |
| Entraînement complet | 2 | 3 267 Mo |
| Entraînement complet | 4 | 4 741 Mo |
| Entraînement complet | 8 | 6 484 Mo |
| Entraînement complet, longueur 64 | 4 | 3 090 Mo |
| Entraînement complet, longueur 512 | 4 | 6 489 Mo |
| Entraînement + points de contrôle de gradient | 8 | 4 102 Mo |
| Entraînement en 16 bits (bfloat16) | 8 | 4 259 Mo |
| Adaptateur LoRA + points de contrôle, 460 800 entraînables | 8 | 2 145 Mo |

Voici comment le lire :

- **Entrer ne dit pas grand-chose.** Avec un lot de 8, l’exécution exige 1 269 Mo et l’entraînement 6 484 Mo, soit 5,1 fois plus. Par rapport aux seuls 538 Mo des poids, l’entraînement en prend 12 fois autant.
- **Avec un lot de 1, vous payez les coûts fixes.** Un seul exemple coûte quand même 3 093 Mo. Réduire la taille du lot a un plancher, qui se situe à environ quatre fois les poids.
- **La longueur et le lot pèsent autant.** Un lot de 4 à longueur 512 (2 048 jetons) exige à peu près autant qu’un lot de 8 à longueur 256 (2 048 jetons) : 6 489 et 6 484 Mo. Les longs documents sont une décision de mémoire, et les tronquer ou les découper économise autant que réduire le lot.
- **Les correctifs agissent sur des lignes différentes.** Les [points de contrôle de gradient](https://arxiv.org/abs/1604.06174) recalculent les activations au lieu de les garder, ce qui a économisé 37 % ici, au prix de calculs supplémentaires. Les nombres de 16 bits réduisent tout de moitié en principe; mesurés, ils ont économisé 34 %, puisque le pic comprend aussi du surcoût. [LoRA](https://arxiv.org/abs/2106.09685) gèle les poids et n’entraîne que de petites matrices ajoutées, si bien que les gradients et l’état de l’optimiseur disparaissent presque : 460 800 paramètres entraînables, 0,34 % du modèle.

Ces chiffres viennent d’un petit modèle sur un processeur. Les cartes graphiques gardent d’autres mémoires tampons et n’ont pas été testées ici : voyez-y un plancher et gardez une marge.

## Le mesurer vous-même

Voici le cœur d’une mesure. Elle doit s’exécuter dans un nouveau processus, parce que le pic ne redescend jamais.

```python
import resource, sys, torch
from transformers import AutoModelForCausalLM

def peak_mb():
    v = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
    return v / (1024 ** 2 if sys.platform == "darwin" else 1024)

model = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM2-135M-Instruct", dtype=torch.float32)
model.gradient_checkpointing_enable()        # retirez cette ligne pour comparer
model.config.use_cache = False
model.train()
opt = torch.optim.AdamW(model.parameters(), 1e-4)
x = torch.randint(0, 1000, (8, 256))
for _ in range(2):                           # l'état d'Adam existe à partir de la deuxième étape
    model(input_ids=x, labels=x).loss.backward()
    opt.step()
    opt.zero_grad(set_to_none=False)
print("pic en Mo :", round(peak_mb()))
```

La deuxième boucle n’est pas un détail. Adam alloue son état à la première mise à jour : un test d’une seule étape donne donc un chiffre trop bas et vous envoie vers un plantage à l’étape deux.

> **À essayer :** lancez le script avec `(1, 256)`, `(4, 256)` et `(8, 256)` dans trois processus distincts, tracez les trois pics selon la taille du lot et lisez votre coût fixe et votre coût par exemple.

## Comment estimer votre budget avant de lancer une exécution?

Additionnez les lignes, puis gardez une marge. Voici une formule rapide, où P est le nombre de paramètres en milliards et O, le nombre d’octets par poids :

| Travail | Mémoire fixe, en Go |
|---|---|
| Exécution | P × O |
| Entraînement complet avec Adam | P × O × 4 (plus si l’état reste en 32 bits) |
| LoRA | P × O + une très petite part |

Calculé pour un modèle de 7 milliards de paramètres à 2 octets par poids, avant toute activation :

| Travail | Mémoire fixe |
|---|---|
| Exécution | 14 Go |
| Entraînement complet | 56 Go |
| LoRA sur des poids gelés | Environ 14 Go |

Une machine dotée de 24 Go de mémoire graphique peut donc facilement contenir ce modèle pour l’exécuter, ne peut pas l’entraîner en entier et peut souvent y entraîner un adaptateur. Ce dernier cas peut exiger le chargement en précision réduite expliqué dans [l’article sur la quantification](/fr/apprendre/quantification-gguf-q4-mxfp4-fp8/), car 14 Go laissent peu de place aux activations. Aucune de ces trois lignes n’a été exécutée ici; c’est de l’arithmétique fondée sur le comportement du petit modèle, et aucun GPU de cette taille n’a été testé.

Pour connaître la part des activations, faites comme ce projet : exécutez deux vraies étapes d’entraînement avec votre plus long exemple et la taille de lot prévue, lisez le pic, puis doublez le lot et regardez comment il augmente. Deux minutes de ce test en disent plus que n’importe quel tableau. Vous saurez aussi quel correctif essayer d’abord : si les coûts fixes dominent, utilisez un adaptateur ou une précision réduite; si les activations dominent, raccourcissez les séquences, réduisez le lot ou activez les points de contrôle. Le [projet 13](/fr/apprendre/diagnostiquer-entrainement-avant-plus-grosse-machine/) couvre ce qu’il faut regarder avant de décider que la mémoire est bien le vrai problème.

## Sources

- Training Deep Nets with Sublinear Memory Cost: https://arxiv.org/abs/1604.06174
- LoRA: Low-Rank Adaptation of Large Language Models: https://arxiv.org/abs/2106.09685
- Adam: A Method for Stochastic Optimization: https://arxiv.org/abs/1412.6980

---

Tiré du Guide de l’intelligence artificielle, par Robert Scales, publié par Holistic Hybrid inc. Partage et adaptation permis selon la licence CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/) : citez le guide, mettez un lien vers https://guidetoartificialintelligence.com/fr/apprendre/budget-memoire-entrer-ou-entrainer-modele/, pas d’usage commercial sans permission, et gardez la même licence.