Combien de temps prend l'optimisation ?

Avec 100 itérations et 3 prompts par itération, comptez 2 à 4 heures sur une RTX 4070 avec un modèle 7-8B. Lancez le soir, récupérez le matin.

Faut-il re-optimiser quand Ollama se met à jour ?

Les mises à jour d'Ollama changent rarement le comportement des paramètres. En revanche, si vous changez de version du modèle, il est recommandé de re-lancer l'optimisation.

Mirostat ou temperature + top_p ?

En général, Mirostat 2 excelle pour les textes longs. Pour les tâches courtes et précises, le contrôle direct via temperature + top_p donne de meilleurs résultats. AutoResearch teste les deux approches.

Accueil › Blog › AutoResearch Ollama Config

⚙️ AutoResearch Variant

AutoResearch Ollama : optimiser automatiquement les paramètres de vos modèles

Q: Les paramètres par défaut d'Ollama sont-ils mauvais ?

Pas mauvais, mais génériques. Les défauts sont un compromis pour toutes les tâches. AutoResearch Ollama trouve les paramètres spécifiques à votre usage, ce qui fait typiquement une différence de 1.5 à 2.5 points sur 10.

Temperature, top_p, top_k, repeat_penalty — laissez la machine trouver les réglages parfaits

Par l'équipe OutilsIA • avril 2026 • 17 min de lecture

« Quelle temperature pour du code ? Quel top_p pour de la création littéraire ? Quel repeat_penalty pour un chatbot ? Arrêtez de deviner — AutoResearch Ollama trouve la réponse en testant 100 combinaisons pendant que vous faites autre chose. »

Chaque modèle IA local a des dizaines de paramètres de génération. La plupart des utilisateurs d'Ollama laissent les valeurs par défaut — et ratent des améliorations significatives. Inspiré de la boucle AutoResearch de Karpathy, ce système applique le principe de mutation-test-sélection aux paramètres de génération eux-mêmes.

Le résultat ? Un Modelfile Ollama personnalisé pour chaque combinaison modèle + tâche, optimisé scientifiquement plutôt qu'au feeling. Temperature 0.3 pour le code, 1.1 pour la création littéraire, 0.0 pour le factuel — mais avec les bonnes valeurs de top_p, top_k et repeat_penalty qui font toute la différence.

Dans cet article : explication de chaque paramètre, code Python complet, démo interactive avec sliders animés, et résultats concrets.

📚 Les paramètres Ollama expliqués

Avant d'optimiser, il faut comprendre ce que chaque paramètre fait. Voici les 7 paramètres clés que notre boucle AutoResearch va explorer :

🌡

temperature (0.0 à 2.0)

Contrôle l'aléatoire de la génération. 0.0 = déterministe (toujours le même résultat). 2.0 = très créatif mais potentiellement incohérent.

Code : 0.0-0.3 Factuel : 0.1-0.4 Créatif : 0.7-1.2

📈

top_p (0.0 à 1.0)

Nucleus sampling : ne considère que les tokens dont la probabilité cumulée atteint top_p. 0.9 = considère les 90% les plus probables. Plus bas = plus conservateur.

Précis : 0.5-0.7 Standard : 0.8-0.95 Libre : 0.95-1.0

🎯

top_k (1 à 100)

Limite le choix aux K tokens les plus probables à chaque étape. top_k=1 = greedy decoding. top_k=40 = valeur classique. top_k=100 = très libre.

🔁

repeat_penalty (0.8 à 2.0)

Pénalise la répétition de tokens déjà générés. 1.0 = pas de pénalité. 1.1-1.3 = réduit les répétitions. Au-dessus de 1.5 = peut dégrader la qualité.

🤖

mirostat / mirostat_eta / mirostat_tau (avancé)

Algorithme alternatif de sampling qui maintient une perplexité cible. mirostat=2 avec tau=5.0 et eta=0.1 donne souvent des résultats plus cohérents que temperature + top_p classiques.

📏

num_predict (1 à 4096+)

Nombre maximum de tokens à générer. Affecte la longueur de la réponse. Trop bas = réponses tronquées. Trop haut = réponses verbatiques.

💡 Le problème : ces paramètres interagissent entre eux. Une temperature de 0.7 avec top_p=0.9 ne donne pas le même résultat qu'avec top_p=0.5. Et l'optimal varie selon le modèle ET la tâche. C'est pourquoi l'exploration automatique est indispensable.

🧬 AutoResearch appliqué aux paramètres Ollama

La boucle est simple : on génère des combinaisons de paramètres, on les teste sur un benchmark standardisé, et on garde les meilleures.

🎲

Config

Générer temp, top_p, top_k, etc.

⚡

Générer

Ollama produit N réponses

🔍

Évaluer

Score qualité via juge LLM

🔁

Sélection

Garder les meilleurs params

Espace de recherche

Paramètre	Min	Max	Pas	Combinaisons
temperature	0.0	2.0	0.1	21
top_p	0.1	1.0	0.05	19
top_k	1	100	5	20
repeat_penalty	0.8	2.0	0.1	13

Total théorique : 21 × 19 × 20 × 13 = 103 740 combinaisons. AutoResearch explore intelligemment cet espace avec un sampling guidé, pas du brute force.

🛠️ Code Python complet

Le générateur de configurations

autoresearch_ollama.py — générateur de configs

import requests, json, random, time

from dataclasses import dataclass, asdict

@dataclass

class OllamaConfig:

temperature: float = 0.7

top_p: float = 0.9

top_k: int = 40

repeat_penalty: float = 1.1

mirostat: int = 0

mirostat_eta: float = 0.1

mirostat_tau: float = 5.0

def random_config():

"""Génère une config aléatoire"""

return OllamaConfig(

temperature=round(random.uniform(0.0, 2.0), 1),

top_p=round(random.uniform(0.1, 1.0), 2),

top_k=random.choice(range(1, 101, 5)),

repeat_penalty=round(random.uniform(0.8, 2.0), 1),

mirostat=random.choice([0, 2]),

)

Le benchmark standardisé

autoresearch_ollama.py — benchmark et évaluation

# Benchmarks par type de tâche

BENCHMARKS = {

"code": [

"Écris une fonction Python qui trie une liste par fréquence",

"Implémente un cache LRU en Python",

"Écris un parser JSON minimal sans bibliothèque",

"creation": [

"Écris un poème sur l'intelligence artificielle",

"Invente une histoire courte de science-fiction",

"Rédige un dialogue entre un humain et une IA",

"factuel": [

"Explique le fonctionnement des transformers",

"Quelles sont les différences entre TCP et UDP ?",

"Comment fonctionne la quantization de modèles IA ?",

}

def benchmark_config(model, config, task_type):

"""Teste une config sur le benchmark"""

scores = []

for prompt in BENCHMARKS[task_type]:

response = requests.post(

"http://localhost:11434/api/generate",

json={

"model": model,

"prompt": prompt,

"options": asdict(config),

"stream": False

}

)

output = response.json()["response"]

score = judge_response(output, prompt, task_type)

scores.append(score)

return sum(scores) / len(scores)

La boucle principale

autoresearch_ollama.py — boucle AutoResearch

def autoresearch_ollama(model, task_type, max_iters=100):

best_config = OllamaConfig() # défaut Ollama

best_score = benchmark_config(model, best_config, task_type)

print(f"Baseline: {best_score:.1f}/10")

for i in range(max_iters):

config = random_config()

score = benchmark_config(model, config, task_type)

if score > best_score:

print(f"[#{i+1}] NEW BEST: {score:.1f}/10")

print(f" temp={config.temperature} top_p={config.top_p} "

f"top_k={config.top_k} repeat={config.repeat_penalty}")

best_config = config

best_score = score

# Générer le Modelfile optimal

generate_modelfile(model, best_config, task_type)

return best_config, best_score

Génération du Modelfile optimal

autoresearch_ollama.py — export Modelfile

def generate_modelfile(model, config, task):

"""Génère un Modelfile Ollama optimisé"""

content = (

f"FROM {model}\n\n"

f"# AutoResearch Ollama - optimisé pour: {task}\n"

f"PARAMETER temperature {config.temperature}\n"

f"PARAMETER top_p {config.top_p}\n"

f"PARAMETER top_k {config.top_k}\n"

f"PARAMETER repeat_penalty {config.repeat_penalty}\n"

)

filename = f"Modelfile.{model}.{task}"

with open(filename, "w") as f:

f.write(content)

print(f"Modelfile sauvé: {filename}")

print(f"Utilisation: ollama create {model}-{task} -f {filename}")

🎮 Démo interactive : optimisation en temps réel

Choisissez un modèle et un type de tâche, puis regardez les sliders de paramètres s'ajuster automatiquement au fil des itérations.

Modèle Ollama

Type de tâche

Vitesse :

Paramètres en cours de test

temperature 0.7

top_p 0.90

top_k 40

repeat_penalty 1.1

Itérations

Améliorations

Meilleur

Actuel

Score du meilleur

02.55.07.510

Évolution du score

$ python autoresearch_ollama.py --model llama3 --task code --iters 22

📈 Résultats concrets par modèle et tâche

Voici les paramètres optimaux trouvés par AutoResearch Ollama après 100 itérations sur chaque combinaison :

Modèle + Tâche	temp	top_p	top_k	repeat	Score
Llama 3 8B — Code	0.2	0.70	15	1.1	8.4
Llama 3 8B — Créatif	1.0	0.95	70	1.05	8.7
Mistral 7B — Factuel	0.1	0.60	10	1.2	8.9
Mistral 7B — Conversation	0.7	0.85	40	1.1	8.2
Phi-3 3.8B — Code	0.1	0.65	10	1.15	7.8
Gemma 2 9B — Créatif	1.1	0.95	80	1.0	8.5

💡 Enseignements clés

• Le code aime le froid : temperature 0.0-0.2 et top_k bas donnent systématiquement les meilleurs résultats
• La création veut de la liberté : temperature haute + top_k élevé + repeat_penalty basse
• Le factuel est greedy : les meilleurs scores viennent de configs très déterministes
• Chaque modèle est différent : Llama 3 et Mistral n'ont pas les mêmes optimaux
• Les défauts Ollama ne sont jamais optimaux : gain moyen de +1.5 à +2.5 points

🧠 Bonus : Mirostat, l'alternative méconnue

Mirostat est un algorithme de sampling adaptatif qui remplace le duo temperature + top_p. Au lieu de fixer des valeurs statiques, il maintient une perplexité cible automatiquement.

Mirostat 2 (recommandé)

• mirostat: 2 — active l'algorithme v2
• mirostat_tau: 5.0 — perplexité cible (plus bas = plus prévisible)
• mirostat_eta: 0.1 — vitesse d'apprentissage

Quand l'utiliser

• Textes longs et cohérents
• Conversations naturelles
• Quand temp + top_p donnent des résultats erratiques
• AutoResearch peut tester les deux approches automatiquement

# Modelfile avec Mirostat

FROM llama3:8b

PARAMETER mirostat 2

PARAMETER mirostat_tau 4.0

PARAMETER mirostat_eta 0.1

Questions fréquentes

Pas "mauvais", mais génériques. Les défauts (temperature=0.8, top_p=0.9, top_k=40) sont un compromis pour toutes les tâches. Pour du code, c'est trop créatif. Pour de la fiction, pas assez. AutoResearch Ollama trouve les paramètres spécifiques à votre usage, ce qui fait typiquement une différence de 1.5 à 2.5 points sur 10.

Avec un benchmark de 3 prompts par itération et 100 itérations, comptez 2 à 4 heures sur une RTX 4070 avec un modèle 7-8B. Lancez le soir, récuprez le matin. C'est un investissement unique par combinaison modèle + tâche.

Les mises à jour d'Ollama changent rarement le comportement des paramètres de génération. En revanche, si vous changez de version du modèle (ex: Llama 3 → Llama 3.1), il est recommandé de re-lancer l'optimisation. Les différentes versions d'un modèle peuvent réagir différemment aux mêmes paramètres.

C'est justement ce que AutoResearch Ollama découvre pour vous ! En général, Mirostat 2 excelle pour les textes longs (conversations, rédaction). Pour les tâches courtes et précises (code, QA factuel), le contrôle direct via temperature + top_p donne souvent de meilleurs résultats. La boucle AutoResearch teste les deux approches et tranche objectivement.