Accueil › Blog › Régler Ollama automatiquement

Régler Ollama automatiquement : ce qu'une boucle de mesure trouve vraiment sur une RTX 4080 SUPER

Par

Publié en avril 2026 · Réécrit le 10 octobre 2026 · Campagne du 9 octobre 2026, Ollama 0.18.2

L'essentiel

Nous avons fait tourner une boucle de réglage automatique d'Ollama sur une RTX 4080 SUPER 16 Go : 13 configurations, chacune chargée à froid puis mesurée trois fois. Résultat net : quand le modèle tient dans la VRAM, les réglages par défaut d'Ollama sont déjà les bons ; la boucle n'a rien trouvé de mieux. Quand le modèle déborde, le seul réglage qui compte est le nombre de couches placées sur la carte (num_gpu) : sur Mixtral 8x7B (26 Go), le meilleur résultat est venu du choix automatique d'Ollama (4,6 tok/s), devant toutes les valeurs forcées, parce qu'il tient compte de la VRAM réellement libre au moment du chargement. La boucle sert donc surtout à vérifier, en une heure, que votre machine n'est pas mal réglée.

Article réécrit le 10 octobre 2026 à partir d'une campagne réelle du 9 octobre 2026. Machine unique, méthode et script complets ci-dessous : vous pouvez refaire la même mesure chez vous.

D'où vient l'idée : autoresearch de Karpathy

En mars 2026, Andrej Karpathy a publié autoresearch : un agent modifie le fichier d'entraînement d'un petit modèle, lance un entraînement limité à 5 minutes, compare le score de validation au précédent, garde la modification si elle améliore le score et la jette sinon. Puis il recommence.

Le même schéma « essayer, mesurer, garder le meilleur » s'applique à l'inférence locale, avec une différence de taille : ici, on ne modifie pas de code, on fait varier quelques options d'Ollama. L'espace à explorer est petit (quelques dizaines de combinaisons utiles), si bien qu'une simple grille suffit. Pas besoin d'agent ni d'optimisation bayésienne.

Ce qu'on peut vraiment régler dans Ollama

RéglageCe qu'il faitEffet attendu sur la vitesse
num_gpuNombre de couches du modèle placées sur la carte graphique (le reste va sur le processeur)Décisif si le modèle ne tient pas entièrement en VRAM
num_ctxTaille de la fenêtre de contexte. Par défaut 4 096 tokens sur une carte de moins de 24 Go (doc Ollama)Neutre tant que le cache tient en VRAM, puis forte baisse
num_batchTaille des lots pour lire le promptJoue sur la lecture du prompt, pas sur la génération
QuantificationChoisie au téléchargement, via le tag du modèle (par exemple :8b-instruct-2512-q8_0)Un fichier plus léger va plus vite et tient mieux en VRAM, au prix d'un peu de qualité

Deux idées reçues à écarter. D'abord, Ollama ne charge pas « du FP16 par défaut » : les tags par défaut sont quantifiés en 4 bits. Sur notre machine, ollama show indique Q4_K_M pour mistral:latest et Q4_0 pour mistral-nemo:12b. Ensuite, on ne gagne pas un facteur 8 en changeant quelques options sur un modèle qui tient déjà en VRAM : nos mesures le confirment.

La campagne : machine et protocole

Résultats

1. Modèle trop gros pour la carte : Mixtral 8x7B (26 Go en Q4_0)

num_gpu (couches sur la carte, sur 32)Part en VRAMGénération (médiane, min–max)Lecture du prompt
auto (choix d'Ollama)45 % GPU / 55 % CPU, 12,6 Go4,6 tok/s (4,6–4,7)49,4 tok/s
827 % GPU / 73 % CPU, 7,6 Go3,4 tok/s (3,3–3,8)40,8 tok/s
1239 % GPU / 61 % CPU, 10,9 Go3,3 tok/s (2,3–3,5)42,6 tok/s
14VRAM saturée (15,8 Go sur 16)mesure interrompue, voir ci-dessous—

Le choix automatique d'Ollama a placé 45 % du modèle (12,6 Go) sur la carte et donné la meilleure vitesse : 4,6 tok/s. Forcer moins de couches (8 ou 12) coûte environ un quart de la vitesse. Forcer davantage est risqué : lors d'un premier essai, alors que le bureau Windows occupait 4,9 Go de VRAM, num_gpu à 14 a saturé la carte (15,8 Go sur 16) et la mesure ne s'est pas terminée en plusieurs minutes ; nous l'avons interrompue. La bonne valeur dépend de la VRAM libre au moment du chargement, et c'est précisément ce que mesure le mode automatique. Le vrai gain ne viendra donc pas d'un réglage mais d'un modèle plus petit : Mistral NeMo 12B, entièrement sur la carte, va 18 fois plus vite (83,6 tok/s).

2. Le coût d'un débordement : Mistral 7B forcé à laisser des couches au processeur

Pour chiffrer le coût d'un débordement, nous avons forcé Mistral 7B, qui tient normalement entièrement sur la carte (124,4 tok/s), à laisser une partie de ses 32 couches au processeur. Avec 24 couches sur la carte (75 % du modèle), la vitesse tombe à 5,6 tok/s ; avec 16 couches, à 3,7 tok/s. Pendant ces deux mesures, le processeur était très sollicité par d'autres travaux (charge moyenne relevée au-dessus de 40 juste après) : les valeurs exactes sont pessimistes, mais un premier essai dans de meilleures conditions donnait déjà moins de 15 tok/s avec 24 couches. Leçon : un modèle qui déborde, même d'un quart, perd l'essentiel de l'avantage de la carte graphique. Nous n'avons pas publié les essais à 8 couches et sans GPU, interrompus pour la même raison.

3. Taille du contexte : Mistral NeMo 12B

num_ctxTaille chargéePlacementGénération (médiane, min–max)
4096 (défaut)7,7 Go100 % GPU83,6 tok/s (83,6–83,7)
1638410,5 Go100 % GPU83,2 tok/s (82,2–83,4)
3276814,5 Go92 % GPU / 8 % CPU17,4 tok/s (16,6–18,3)
6553622,2 Go60 % GPU / 40 % CPU4,6 tok/s (4,2–4,9)

Jusqu'à 16 384 tokens, le cache tient dans la carte et la vitesse ne bouge pas (83,6 puis 83,2 tok/s). À 32 768 tokens, l'ensemble pèse 14,5 Go : 8 % passe sur le processeur et la vitesse est divisée par près de cinq (17,4 tok/s). À 65 536, 40 % du modèle est sur le processeur : 4,6 tok/s. Augmentez le contexte seulement si vous en avez besoin, et vérifiez avec ollama ps que le placement reste à 100 % GPU.

4. Taille des lots : Mistral NeMo 12B, prompt d'environ 309 tokens

num_batchLecture du prompt (médiane)Génération (médiane, min–max)
128876,9 tok/s82,3 tok/s (82,3–82,7)
5121007,5 tok/s82,2 tok/s (81,6–82,3)
20484185,5 tok/s80,9 tok/s (76,6–81,7)

La vitesse de génération ne bouge pas (82,3, 82,2 et 80,9 tok/s, des écarts dans le bruit de mesure). La lecture du prompt est nettement plus rapide quand le lot couvre tout le prompt (4 185 tok/s avec num_batch à 2048, contre 877 et 1 008), mais sur un prompt aussi court cette mesure dépend aussi de la montée en fréquence de la carte : retenez la tendance, pas le chiffre. num_batch ne compte que pour les longs prompts (documents, RAG), et il se paie en VRAM : 10,4 Go chargés contre 8,2 Go.

Le script utilisé, tel quel

C'est le script exact de la campagne (Python 3, bibliothèque standard uniquement). Il lit une liste de configurations dans un fichier JSON, mesure chacune et écrit une ligne de résultats par configuration.

#!/usr/bin/env python3
"""ollama_tune.py - mesure les tok/s d'Ollama pour plusieurs jeux d'options.

Usage : python3 ollama_tune.py campagne.json resultats.jsonl
campagne.json = liste de {"model": "...", "label": "...", "options": {...}}
Chaque config : 1 passe de chauffe (non comptée) + N passes mesurées.
Les tok/s viennent des compteurs renvoyés par Ollama (eval_count / eval_duration).
Garde-fou : une passe n'est comptée que si aucun autre modèle n'est chargé dans Ollama
et que la carte NVIDIA était au repos juste avant (moins de 60 W selon nvidia-smi, si présent).
"""
import json
import shutil
import statistics
import subprocess
import sys
import time
import urllib.request

HOST = "http://localhost:11434"
PROMPT = ("Explique en français, en 6 paragraphes, comment fonctionne la quantification "
          "d'un modèle de langage et quels compromis elle implique pour un usage local.")
RUNS = 3
NUM_PREDICT = 256


def call(path, payload=None):
    data = json.dumps(payload).encode() if payload is not None else None
    req = urllib.request.Request(HOST + path, data=data,
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=1800) as r:
        return json.loads(r.read())


def unload(model):
    # keep_alive=0 décharge le modèle : chaque config repart d'un chargement propre
    call("/api/generate", {"model": model, "keep_alive": 0, "prompt": ""})
    time.sleep(2)


def one_run(model, options, prompt):
    opts = {"temperature": 0, "seed": 42, "num_predict": NUM_PREDICT}
    opts.update(options)
    r = call("/api/generate", {"model": model, "prompt": prompt,
                               "stream": False, "options": opts})
    return {
        "gen_tok_s": r["eval_count"] / (r["eval_duration"] / 1e9),
        "prompt_tok_s": r.get("prompt_eval_count", 0) / max(r.get("prompt_eval_duration", 1) / 1e9, 1e-9),
        "prompt_tokens": r.get("prompt_eval_count", 0),
        "gen_tokens": r["eval_count"],
        "load_s": r.get("load_duration", 0) / 1e9,
    }


def others(model):
    return [m["name"] for m in call("/api/ps").get("models", []) if m["name"] != model]


def gpu_busy():
    if not shutil.which("nvidia-smi"):
        return False
    # consommation électrique plutôt que % d'utilisation : au repos, l'affichage Windows
    # fait monter le pourcentage à fréquence minimale sans réel calcul
    out = subprocess.run(["nvidia-smi", "--query-gpu=power.draw", "--format=csv,noheader,nounits"],
                         capture_output=True, text=True).stdout.split()
    return bool(out) and float(out[0]) > 60


def clean_run(model, options, prompt):
    """Attend que la machine soit calme, mesure, et recommence si un autre modèle est apparu."""
    for _ in range(60):
        while others(model) or gpu_busy():
            time.sleep(10)
        r = one_run(model, options, prompt)
        if not others(model):
            return r
    raise RuntimeError("machine jamais au calme")


def placement(model):
    for m in call("/api/ps").get("models", []):
        if m["name"] == model or m.get("model") == model:
            total, vram = m.get("size", 0), m.get("size_vram", 0)
            return {"size_gb": round(total / 1e9, 1), "vram_gb": round(vram / 1e9, 1),
                    "gpu_pct": round(100 * vram / total) if total else None,
                    "ctx": m.get("context_length")}
    return {}


def main(campaign_file, out_file):
    campaign = json.load(open(campaign_file))
    version = call("/api/version")["version"]
    for cfg in campaign:
        model, options = cfg["model"], cfg.get("options", {})
        prompt = PROMPT * cfg.get("prompt_repeat", 1)
        unload(model)
        while others(model) or gpu_busy():  # autre modèle chargé ou carte occupée : on attend
            time.sleep(10)
        row = {"model": model, "label": cfg.get("label", ""), "options": options,
               "ollama": version, "date": time.strftime("%Y-%m-%d %H:%M")}
        try:
            first = one_run(model, options, prompt)  # chauffe : chargement + premier passage
            row["load_s"] = round(first["load_s"], 1)
            row["placement"] = placement(model)
            # préfixe différent à chaque passe : évite que le cache de prompt fausse la mesure
            runs = [clean_run(model, options, f"[Essai {i}] " + prompt) for i in range(1, RUNS + 1)]
            gen = [x["gen_tok_s"] for x in runs]
            row.update({
                "gen_tok_s_median": round(statistics.median(gen), 1),
                "gen_tok_s_min": round(min(gen), 1),
                "gen_tok_s_max": round(max(gen), 1),
                "prompt_tok_s_median": round(statistics.median(x["prompt_tok_s"] for x in runs), 1),
                "prompt_tokens": runs[0]["prompt_tokens"],
                "gen_tokens": [x["gen_tokens"] for x in runs],
            })
        except Exception as exc:  # OOM, timeout, option refusée
            row["error"] = str(exc)[:300]
        print(json.dumps(row, ensure_ascii=False), flush=True)
        with open(out_file, "a") as f:
            f.write(json.dumps(row, ensure_ascii=False) + "\n")
    unload(campaign[-1]["model"])


if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2])

Exemple de fichier de campagne (campagne.json) pour chercher le meilleur num_gpu d'un modèle qui déborde :

[
 {"model": "nous-hermes2-mixtral:8x7b", "label": "auto"},
 {"model": "nous-hermes2-mixtral:8x7b", "label": "num_gpu", "options": {"num_gpu": 12}},
 {"model": "nous-hermes2-mixtral:8x7b", "label": "num_gpu", "options": {"num_gpu": 14}}
]
python3 ollama_tune.py campagne.json resultats.jsonl

Pour transformer la grille en boucle « à la autoresearch », il suffit de générer la configuration suivante à partir de la meilleure trouvée (par exemple num_gpu + 1 tant que le modèle se charge sans erreur). Sur ce problème, ce raffinement n'apporte presque rien : la grille complète prend moins d'une heure.

Comment s'en servir chez vous

  1. Lancez votre modèle habituel puis ollama ps. Si la colonne PROCESSOR affiche 100% GPU, ne cherchez pas plus loin : gardez les réglages par défaut.
  2. Si elle affiche un partage CPU/GPU, lancez une petite grille sur num_gpu autour de la valeur choisie automatiquement, puis comparez à un modèle plus petit ou plus quantifié : c'est souvent le vrai gain.
  3. Si vous avez besoin d'un long contexte, mesurez la vitesse à la taille réellement utilisée : le défaut de 4 096 tokens peut masquer un débordement qui n'apparaîtra qu'à 32 000.

Questions fréquentes

Faut-il régler Ollama à la main pour aller plus vite ?

Pas si le modèle tient entièrement dans la VRAM : sur notre RTX 4080 SUPER, aucun réglage testé n'a battu la configuration par défaut d'Ollama pour Mistral 7B et Mistral NeMo 12B. Le réglage n'a d'intérêt que pour un modèle qui déborde sur le processeur.

Quel réglage compte le plus quand le modèle ne tient pas en VRAM ?

Le nombre de couches placées sur la carte, l'option num_gpu. Sur Mixtral 8x7B, le choix automatique d'Ollama (45 % du modèle sur la carte) a donné 4,6 tokens par seconde, mieux que 8 ou 12 couches forcées (3,4 et 3,3). Le vrai gain vient d'un modèle plus petit qui tient entièrement en VRAM.

Augmenter num_ctx ralentit-il la génération ?

Pas tant que le cache tient en VRAM. Avec Mistral NeMo 12B, la vitesse reste stable de 4 096 à 16 384 tokens de contexte, puis s'effondre quand le modèle et son cache dépassent la mémoire de la carte : 17,4 tokens par seconde à 32 768 tokens de contexte, 4,6 à 65 536.

À quoi sert num_batch ?

Il règle la taille des lots pendant la lecture du prompt. Sur un prompt de 309 tokens, il n'a pas changé la vitesse de génération (environ 82 tokens par seconde dans tous les cas).

Ollama charge-t-il les modèles en FP16 par défaut ?

Non. Les tags par défaut de la bibliothèque Ollama sont quantifiés en 4 bits : ollama show indique Q4_K_M pour mistral:latest et Q4_0 pour mistral-nemo:12b sur notre machine. Pour une autre quantification, il faut télécharger un autre tag.

Combien de temps dure une campagne de réglage ?

Comptez quelques secondes par configuration pour un modèle qui tient en VRAM, et plusieurs minutes pour un modèle qui déborde (chargement de 26 Go, génération à quelques tokens par seconde). Notre campagne de 13 configurations a pris environ une heure, attentes comprises.

Mesurez sur votre vraie machine Scan CPU/GPU/VRAM, Ollama, modèle compatible, benchmark tokens/s. Gratuit, sans vente forcée. Télécharger Local Cockpit Estimer mon PC

Sources : karpathy/autoresearch · doc Ollama, longueur de contexte · doc Ollama, paramètres du Modelfile. Mesures : OutilsIA, 9 octobre 2026, une seule machine. Voir aussi Mistral en local : nos mesures sur la même carte et que faire quand Ollama manque de mémoire.

IA locale

→ Guides IA locale & Local Cockpit — hub OutilsIA