# La vitesse d'un modèle local : débit mémoire et experts

> Pourquoi un modèle local écrit vite ou lentement : débit mémoire, paramètres actifs, mélange d'experts, et comment lire la vitesse estimée par QUELLE IA.

- Niveau : Nerd
- Thème : IA locale
- Durée : 15 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/vitesse-locale/

Un modèle de langage écrit un jeton à la fois, un jeton étant un morceau de mot. Pour chacun, il refait le même calcul à travers tous ses paramètres actifs, qu'il doit d'abord lire en mémoire. Sur un ordinateur personnel, cette lecture prend plus de temps que le calcul lui-même. La vitesse d'écriture dépend donc d'abord de deux chiffres : le débit de la mémoire, en Go par seconde, et le nombre d'octets à relire pour chaque jeton.

## À quoi ça sert

- **Prévoir avant d'acheter.** Avec le même modèle, deux machines peuvent écrire à des vitesses très différentes : un Mac mini M6 lit sa mémoire à 153 Go/s, un Mac Studio M5 Ultra à 1 200 Go/s, près de huit fois plus, d'après le registre de QUELLE IA.
- **Comprendre pourquoi un gros modèle va vite.** Un modèle à mélange d'experts de 30 milliards de paramètres peut écrire bien plus vite qu'un modèle dense de 8 milliards.
- **Lire nos fourchettes.** Les pages machines de QUELLE IA affichent une vitesse estimée pour chaque modèle : ce guide dit d'où elle vient et ce qu'elle ne couvre pas.

## Comment ça marche

### La mémoire, goulot d'étranglement

Quand un modèle répond à une seule personne, chaque jeton demande de faire passer tous ses paramètres actifs de la mémoire aux unités de calcul. Databricks résume la situation ainsi : à petite échelle, la génération est limitée par la vitesse à laquelle on charge les paramètres depuis la mémoire, et le débit mémoire dicte la vitesse.

Leur exemple chiffré : un modèle de 7 milliards de paramètres en 16 bits pèse 14 Go. S'il écrit un jeton toutes les 14 millisecondes, il fait passer 14 Go en 14 ms, soit 1 To par seconde. Sur une machine capable de 2 To/s, il en utilise la moitié.

La lecture de votre demande, avant le premier mot de la réponse, suit une autre logique : tous les jetons de la demande se traitent d'un bloc, et c'est la puissance de calcul qui compte. Ce guide parle de la génération, ce qui s'écrit une fois la réponse lancée.

### Le plafond

On en tire un plafond simple :

**vitesse maximale (jetons/s) = débit mémoire (Go/s) ÷ Go relus à chaque jeton**

Les Go relus à chaque jeton valent les paramètres actifs, en milliards, multipliés par le poids d'un milliard de paramètres dans la version installée : 0,6 Go à 4 bits, 1,05 Go à 8 bits, 2 Go en version complète (le guide sur la quantification explique ces versions).

Le tableau de llama.cpp sur Llama 3.1 8B le confirme : passer de la version complète à `Q8_0` divise la taille par 1,9 et fait monter la génération de 29 à 51 jetons par seconde ; `Q4_K_M` atteint 72 jetons par seconde. Moins d'octets à relire, plus de jetons.

### Dense ou mélange d'experts

Un modèle **dense** utilise tous ses paramètres pour chaque jeton. Un modèle à **mélange d'experts** (MoE, pour *mixture of experts*) découpe une partie de ses couches en « experts », et un petit routeur n'en choisit que quelques-uns par jeton. Hugging Face le résume : l'inférence est bien plus rapide qu'avec un modèle dense de même taille, mais tous les paramètres doivent tenir en mémoire.

Sur le mini-PC de QUELLE IA, deux modèles de code le montrent. Leurs fichiers ont presque la même taille, et leurs architectures diffèrent :

![Terminal sombre : ollama show qwen3-coder:30b affiche l'architecture qwen3moe, 30.5B paramètres et la quantification Q4_K_M ; ollama show qwen2.5-coder:32b affiche l'architecture qwen2, 32.8B paramètres et Q4_K_M.](https://quelleia.com/guides/vitesse-locale/terminal-moe-dense.webp)

*Deux modèles de code installés sur le mini-PC Linux de QUELLE IA, vus par ollama show le 17 novembre 2026 : presque la même taille, deux architectures.*

Qwen3-Coder 30B compte 30,5 milliards de paramètres dont 3,3 milliards actifs (128 experts, 8 activés par jeton, selon sa fiche). Qwen2.5-Coder 32B est dense : il relit tous ses paramètres, 32,8 milliards d'après Ollama, à chaque jeton.

![Un modèle dense relit tous ses paramètres à chaque jeton, un mélange d'experts seulement ceux qu'il active. Le plafond est calculé ici avec le débit du DGX Spark et la version à 4 bits.](https://quelleia.com/guides/vitesse-locale/schema-parametres-actifs.svg)

*Un modèle dense relit tous ses paramètres à chaque jeton, un mélange d'experts seulement ceux qu'il active. Le plafond est calculé ici avec le débit du DGX Spark et la version à 4 bits.*

À débit égal, le premier relit dix fois moins de mémoire par jeton. Avec le débit d'un DGX Spark (273 Go/s) et la version à 4 bits, le plafond est d'environ 14 jetons par seconde pour le modèle dense et 140 pour le mélange d'experts. Pour la mémoire, en revanche, on compte le total : à 4 bits, les deux demandent de 21 à 23 Go, conversation courte comprise.

## Du plafond à la vitesse réelle

Les machines mesurées restent sous ce plafond. Le moteur, le cache de la conversation et les calculs annexes prennent leur part. Le registre de QUELLE IA garde des mesures publiées pour situer l'écart. Le projet llama.cpp a mesuré gpt-oss 120B sur un DGX Spark : 58,72 jetons par seconde en écrivant 32 jetons à contexte vide. Ce modèle active 5,1 milliards de paramètres, rangés au format MXFP4 de 4,25 bits par poids, soit 2,7 Go à relire par jeton. Le plafond est donc de 273 ÷ 2,7, environ 101 jetons par seconde : la mesure en atteint 58 %.

Le contexte compte aussi. Avec 32 768 jetons de conversation déjà en mémoire, la même mesure tombe à 42,76 jetons par seconde : le modèle relit aussi, à chaque jeton, le cache de tout ce qui précède.

## Comment QUELLE IA estime la vitesse

Sur chaque page machine, QUELLE IA montre d'abord les vitesses mesurées et publiées quand il y en a. Pour les autres modèles, le site affiche une fourchette estimée, toujours marquée comme telle.

1. **Le plafond.** Débit mémoire de la machine ÷ (paramètres actifs × Go par milliard de la version la plus complète qui tient sur la machine).
2. **L'étalonnage.** Pour chaque mesure publiée dont on connaît la machine, le modèle et le format, le site calcule la part du plafond atteinte. Il retient la plus petite et la plus grande.
3. **La fourchette.** Plafond × la plus petite part, et plafond × la plus grande. Les deux bornes se recalculent à chaque édition : une nouvelle mesure peut les déplacer.
4. **L'arrondi.** Deux chiffres significatifs, sans décimale au-delà de 10 jetons par seconde.

![Cadre de QUELLE IA intitulé La vitesse estimée, et comment on la calcule : explication du plafond, un exemple de calcul, les bornes de l'étalonnage, puis un tableau des mesures publiées avec la machine, le modèle, le format, le moteur, la vitesse mesurée, le plafond et la part du plafond.](https://quelleia.com/guides/vitesse-locale/methode-vitesse-estimee.webp)

*La méthode de la vitesse estimée sur la page « Sur ma machine » de QUELLE IA, capturée le 17 novembre 2026 (édition du 16 novembre). Les bornes et le tableau d'étalonnage changent quand une mesure s'ajoute.*

Le site ne donne aucune estimation pour quatre sortes de machines et de modèles : une machine dont le débit mémoire n'est pas publié (les Ryzen AI Max, AMD ne publiant pas ce chiffre), une machine à deux mémoires de débits très différents (la DGX Station), une grappe de plusieurs machines reliées par le réseau, et un modèle dont l'éditeur ne publie pas les paramètres actifs. Quelques modèles dont le poids réel en mémoire reste incertain en sont aussi privés, et leur fiche le dit.

> Bon à savoir : l'estimation vaut pour un contexte court. Elle ne compte ni la lecture d'une longue demande, ni les écarts entre moteurs (llama.cpp, Ollama, LM Studio, MLX ou vLLM ne tirent pas le même parti d'une machine), ni la prédiction de plusieurs jetons à la fois, qui peut dépasser le plafond.

Voici, pour une machine de 128 Go, les modèles les mieux classés qui y tiennent. Les pages machines donnent la vitesse estimée de chacun.

**Les meilleurs modèles pour une machine de 128 Go**

1. [Qwen 3.8 27B](https://quelleia.com/modeles/qwen-3-8-27b/) : score 83,1 (complète, 62,1 Go)
2. [Nemotron 3.5 Super VL](https://quelleia.com/modeles/nemotron-3-5-super-vl/) : score 76,1 (allégée à 4 bits, 82,8 Go)
3. [Gemma 4 31B IT](https://quelleia.com/modeles/gemma-4-31b-it/) : score 75,5 (complète, 71,3 Go)
4. [Qwen3.6 27B](https://quelleia.com/modeles/qwen3-6-27b/) : score 75,5 (complète, 63,9 Go)
5. [Muse Glimmer](https://quelleia.com/modeles/muse-glimmer/) : score 73,9 (complète, 69 Go)

Mémoire utile retenue : 112 Go, celle des machines suivies de 128 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.
[Quel modèle sur ma machine](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

## Mesurer sa propre vitesse

### Avec Ollama, dans le terminal

1. Lancez le modèle avec l'option `--verbose`, qui affiche les temps de la réponse :

```bash
ollama run --verbose qwen3-coder:30b "Écris une fonction Python qui trie une liste."
```

![Terminal sombre : ollama run --help, avec l'usage ollama run MODEL [PROMPT] [flags] puis trois options, --keepalive, --think et --verbose, cette dernière décrite par Show timings for response.](https://quelleia.com/guides/vitesse-locale/terminal-run-aide.webp)

*Extrait de l'aide de ollama run sur le mini-PC de QUELLE IA (Ollama 0.21.1) : l'option --verbose affiche les temps de la réponse.*

2. Sous la réponse, Ollama ajoute ses statistiques. Retenez la vitesse de génération des jetons de la réponse, en jetons par seconde, à distinguer de celle de la lecture de la demande.
3. Refaites l'essai deux ou trois fois : le premier lancement inclut le chargement du modèle en mémoire.
4. Vérifiez avec `ollama ps` que la colonne `PROCESSOR` indique « 100% GPU ». Un modèle partagé entre processeur et processeur graphique écrit nettement moins vite que ne le prévoit le calcul.

### Avec l'API d'Ollama, pour un script

La réponse de l'API donne `eval_count`, le nombre de jetons écrits, et `eval_duration`, le temps qu'il a fallu, en nanosecondes. La vitesse vaut `eval_count ÷ eval_duration × 10⁹`.

```bash
curl -s http://localhost:11434/api/generate \
  -d '{"model": "qwen3-coder:30b", "prompt": "Écris une fonction Python qui trie une liste.", "stream": false}' \
  | python3 -c 'import json,sys; r=json.load(sys.stdin); print(round(r["eval_count"]/r["eval_duration"]*1e9, 1), "jetons/s")'
```

Pour comparer deux machines ou deux versions d'un modèle, gardez la même demande, la même longueur de réponse et un contexte vide, comme les mesures de référence de llama.cpp.

## Pour aller plus loin

- [Quel modèle sur ma machine](https://quelleia.com/local/)
- [Dgx spark](https://quelleia.com/local/dgx-spark/)
- [Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)
- [Trouver mon modèle](https://quelleia.com/trouver/)
- [Glossaire](https://quelleia.com/glossaire/)
- [Quantification : Q4, Q8, ce qu'on gagne et ce qu'on perd](https://quelleia.com/guides/quantification.md) (guide, expert)
- [Quel modèle d'IA pour ma machine, de 8 à 128 Go](https://quelleia.com/guides/quel-modele-pour-ma-machine.md) (guide, amateur)
- [Sur mini lab AI](https://minilabai.com/guides/comparatif-machines/) : un guide du même auteur, qui va plus loin

## Sources

- https://www.databricks.com/blog/llm-inference-performance-engineering-best-practices (lue le 17 novembre 2026)
- https://huggingface.co/blog/moe (lue le 17 novembre 2026)
- https://huggingface.co/Qwen/Qwen3-Coder-30B-A3B-Instruct (lue le 17 novembre 2026)
- https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct (lue le 17 novembre 2026)
- https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md (lue le 17 novembre 2026)
- https://docs.ollama.com/api/usage (lue le 17 novembre 2026)
- https://github.com/ggml-org/llama.cpp/blob/master/benches/dgx-spark/dgx-spark.md (lue le 17 novembre 2026)
- https://docs.ollama.com/context-length (lue le 17 novembre 2026)
- https://quelleia.com/local/ (lue le 17 novembre 2026)
