# Évaluer un modèle soi-même : un petit banc d'essai maison

> Bâtir son propre banc d'essai sur ses tâches : jeu de questions, notation par règle ou par un modèle juge et ses biais, au moins trois passages, code complet.

- Niveau : Nerd
- Thème : Code
- Durée : 20 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/evaluer-un-modele-soi-meme/

Un classement public répond à la question « quel modèle est le plus fort en général ? ». Votre question est plus étroite : quel modèle, avec quelle consigne et quel réglage, fait le mieux *votre* travail, au meilleur prix ? Seul un banc d'essai bâti sur vos propres tâches y répond. Il tient en quelques dizaines de questions et un script de cent lignes.

## Le lien avec QUELLE IA

QUELLE IA ne fait passer aucun test elle-même. Le site rassemble chaque semaine les résultats de benchmarks publics, les ramène sur une même échelle et les combine en un score avec sa marge, comme l'explique la page « Démarche ». Ce score sert à dresser une liste courte : les trois ou quatre modèles qui méritent d'être essayés pour une tâche.

**Le haut du classement général**

1. [Claude Fable 5.2](https://quelleia.com/modeles/claude-fable-5-2/) : 105,2 (Anthropic)
2. [Gemini 4 Carbon](https://quelleia.com/modeles/gemini-4-carbon/) : 102,0 (Google DeepMind)
3. [Claude Opus 5.5](https://quelleia.com/modeles/claude-opus-5-5/) : 100,6 (Anthropic)
4. [GPT-6 Astra](https://quelleia.com/modeles/gpt-6-astra/) : 100,1 (OpenAI)
5. [GPT-6.1 Terra](https://quelleia.com/modeles/gpt-6-1-terra/) : 99,3 (OpenAI)

Score IA, édition du 16 novembre 2026. Deux modèles dont les marges se recouvrent sont ex æquo.
[Classement général des modèles de langage](https://quelleia.com/classement/)

Votre banc prend le relais. Il départage ces candidats sur vos cas réels, mesure ce que le classement ne voit pas (votre format, votre langue, votre jargon) et se rejoue à chaque nouveau modèle ou changement de consigne. Anthropic donne le même conseil pour régler l'effort de ses modèles : faire varier le réglage sur ses propres évaluations plutôt que de reprendre celui d'un ancien modèle.

## Comment ça marche

![Un banc d'essai maison en cinq temps : des questions tirées de vos tâches, plusieurs passages, une note par règle ou par un juge, la moyenne et l'écart, puis la décision.](https://quelleia.com/guides/evaluer-un-modele-soi-meme/boucle-banc.svg)

*Un banc d'essai maison en cinq temps : des questions tirées de vos tâches, plusieurs passages, une note par règle ou par un juge, la moyenne et l'écart, puis la décision.*

1. **Le jeu de questions.** Tirez 20 à 50 cas de votre travail réel : des courriels à classer, des documents à résumer, des questions de clients. Pour chacun, écrivez la réponse attendue ou les critères d'une bonne réponse *avant* de lancer le moindre modèle. Mélangez des cas faciles, des cas difficiles et quelques pièges connus.
2. **Les passages.** Un modèle ne répond pas deux fois la même chose. Faites passer chaque question au moins trois fois à chaque candidat, avec les mêmes réglages. Un seul passage peut donner un vainqueur par hasard.
3. **La notation.** Préférez une règle chaque fois que c'est possible : un nombre attendu, un mot-clé présent, un JSON valide, un test unitaire qui passe. Une règle ne se trompe pas et ne coûte rien. Pour les réponses ouvertes (un résumé, un ton), un modèle juge note avec une grille écrite.
4. **La lecture.** Calculez la moyenne et l'écart entre passages. Si deux candidats sont séparés par moins que cet écart, votre banc ne les départage pas : ajoutez des questions ou des passages.
5. **La décision.** Gardez le candidat le moins cher qui atteint le niveau visé, puis rejouez le banc à chaque changement.

## Un banc par règle, pas à pas

L'exemple pose cinq questions à réponse chiffrée et note la réponse par une règle : le premier nombre trouvé doit égaler l'attendu. Il tourne avec Ollama et la seule bibliothèque standard de Python.

1. Enregistrez le script sous `banc.py` :

```python
"""Un petit banc d'essai maison : des questions à réponse vérifiable, n passages, une note par règle.
Aucune dépendance : Python 3.10 ou plus et un serveur Ollama."""
import json, re, statistics, sys, urllib.request

QUESTIONS = [
    ("Combien de jours ouvrés (lundi à vendredi) entre le lundi 2 mars et le vendredi 13 mars 2026 inclus ?", 10),
    ("Combien de minutes dans 1 h 45 min ?", 105),
    ("Un article coûte 80 euros hors taxes. Avec une TVA de 20 %, quel est son prix TTC en euros ?", 96),
    ("Quel montant en euros cite cette phrase : « Le comité, réuni mardi, a validé un budget de 4 200 euros » ?", 4200),
    ("Combien de fois la lettre r apparaît-elle dans le mot « arrière-grand-mère » ?", 5),
]
CONSIGNE = "Réponds uniquement par un nombre entier, sans unité ni phrase."


def demande(modele, question, temperature):
    corps = {"model": modele, "stream": False, "think": False, "options": {"temperature": temperature},
             "messages": [{"role": "system", "content": CONSIGNE}, {"role": "user", "content": question}]}
    req = urllib.request.Request("http://localhost:11434/api/chat", data=json.dumps(corps).encode(),
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=600) as r:
        return json.load(r)["message"]["content"]


def note(reponse, attendu):
    # Notation par règle : le premier nombre de la réponse, espaces retirés, comparé à l'attendu.
    m = re.search(r"\d[\d\s ]*", reponse)
    return int(m is not None and int(re.sub(r"\D", "", m.group())) == attendu)


def banc(modele, passages=3, temperature=0.8):
    scores = []
    for p in range(1, passages + 1):
        resultats = [note(demande(modele, q, temperature), attendu) for q, attendu in QUESTIONS]
        scores.append(sum(resultats) / len(resultats))
        print(f"passage {p} : {sum(resultats)}/{len(resultats)}  {''.join('✓' if r else '✗' for r in resultats)}")
    print(f"{modele} : moyenne {statistics.mean(scores):.2f}, écart-type {statistics.stdev(scores):.2f} "
          f"sur {passages} passages")


if __name__ == "__main__":
    banc(sys.argv[1] if len(sys.argv) > 1 else "gemma4:26b")
```

2. Lancez-le sur un modèle installé, puis sur chaque candidat :

```bash
python3 banc.py gemma4:26b
```

3. Pour comparer deux consignes plutôt que deux modèles, gardez le même modèle et changez `CONSIGNE`.

## Un juge, et ses biais

Pour une réponse ouverte, un modèle peut juger à votre place. L'article de référence sur ce sujet (Zheng et ses coauteurs, 2023, à l'origine de MT-Bench et de Chatbot Arena) trouve que de bons juges s'accordent avec les préférences humaines dans plus de 80 % des cas, autant que deux humains entre eux. Il décrit aussi trois biais :

- **la position** : le juge favorise la réponse placée en premier, ou en second ;
- **la longueur** : il préfère la réponse la plus longue, même quand elle n'apporte rien ;
- **l'auto-préférence** : il favorise les réponses de son propre modèle.

Les parades sont simples. Posez chaque comparaison dans les deux ordres et ne retenez que les verdicts stables. Écrivez dans la grille que la longueur n'est pas un mérite. Prenez un juge d'une autre famille que les modèles jugés.

Ce script applique la première parade. Il demande au juge un verdict contraint par un schéma JSON, puis refait la comparaison en échangeant les réponses :

```python
"""Un juge par un modèle, avec la parade au biais de position : on pose la comparaison dans les deux ordres.
Aucune dépendance : Python 3.10 ou plus et un serveur Ollama."""
import json, urllib.request

JUGE = "gemma4:26b"   # de préférence d'une autre famille que les modèles jugés
SCHEMA = {"type": "object", "properties": {"raison": {"type": "string"}, "gagnant": {"type": "string", "enum": ["1", "2", "egalite"]}},
          "required": ["raison", "gagnant"]}
GRILLE = ("Tu compares deux réponses à la même demande. Critères, dans cet ordre : exactitude, respect de la consigne, "
          "concision. La longueur n'est pas un mérite. Donne une raison en une phrase, puis le gagnant.")


def juge(demande, rep1, rep2):
    corps = {"model": JUGE, "stream": False, "think": False, "format": SCHEMA, "options": {"temperature": 0},
             "messages": [{"role": "system", "content": GRILLE},
                          {"role": "user", "content": f"Demande : {demande}\n\nRéponse 1 : {rep1}\n\nRéponse 2 : {rep2}"}]}
    req = urllib.request.Request("http://localhost:11434/api/chat", data=json.dumps(corps).encode(),
                                 headers={"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=600) as r:
        return json.loads(json.load(r)["message"]["content"])


def compare(demande, a, b):
    v1 = juge(demande, a, b)["gagnant"]                                       # A en position 1
    v2 = {"1": "2", "2": "1"}.get(j := juge(demande, b, a)["gagnant"], j)    # A en position 2, remis à l'endroit
    verdict = {"1": "A", "2": "B"}.get(v1) if v1 == v2 else "égalité ou verdict instable"
    print(f"ordre A,B : {v1}  ordre B,A : {v2}  ->  {verdict}")


if __name__ == "__main__":
    compare("Résume en une phrase : la réunion de mardi est reportée à jeudi 14 h, même salle.",
            "La réunion de mardi est déplacée à jeudi 14 h, dans la même salle.",
            "Bonjour ! Voici un résumé : la réunion qui devait avoir lieu mardi a été reportée. "
            "Elle se tiendra désormais jeudi à 14 h. La salle reste inchangée. N'hésitez pas si besoin !")
```

Les deux scripts ont tourné sur le mini-PC de QUELLE IA :

![Terminal : banc.py gemma4:26b affiche trois passages, 4 sur 5, 5 sur 5 et 4 sur 5, la dernière question ratée deux fois, puis une moyenne de 0,87 et un écart-type de 0,12 sur 3 passages ; juge.py affiche ordre A,B : 1, ordre B,A : 1, verdict A.](https://quelleia.com/guides/evaluer-un-modele-soi-meme/terminal-banc.webp)

*Sorties réelles des deux scripts de ce guide sur le mini-PC Linux de QUELLE IA, le 17 novembre 2026, avec gemma4:26b servi par Ollama 0.21.1.*

Le banc donne 13 bonnes réponses sur 15. La question ratée deux fois est le décompte des « r » dans « arrière-grand-mère » : le modèle lit des morceaux de mots (des jetons) plutôt que des lettres, ce qui rend ce décompte difficile. Avec trois passages seulement, l'écart-type (0,12) est du même ordre que l'écart entre une note de 4 et une note de 5 sur 5 : pour comparer deux modèles proches, il faudrait davantage de questions. Le juge, lui, préfère la réponse courte dans les deux ordres, et le verdict est donc retenu.

## Les pièges

- **Des questions écrites après avoir vu les réponses.** Le banc mesure alors ce que vous avez déjà observé. Figez le jeu de questions avant le premier passage.
- **Un seul passage.** À température non nulle, un modèle peut gagner par chance. Trois passages sont un minimum ; regardez l'écart avant de conclure.
- **Un jeu trop facile.** Si tous les candidats font le plein, le banc ne départage plus personne : il sature, comme un benchmark public. Ajoutez des cas difficiles.
- **Des réglages différents.** Même longueur maximale de réponse, même température, même effort de réflexion pour tous, ou bien chaque réglage devient un candidat à part entière.
- **Des questions réutilisées pour l'entraînement.** Si vous affinez un modèle, gardez des exemples à part pour l'évaluer ; Unsloth conseille d'en réserver 20 %.
- **Oublier le coût et le temps.** Notez pour chaque candidat les jetons consommés et la durée. Un modèle à peine meilleur mais trois fois plus cher n'est pas forcément le bon choix.

## Coût et matériel

En local, un banc ne coûte que du temps machine : les quinze appels de l'exemple ont tourné sur un modèle déjà chargé. Par une API, comptez le nombre de questions × le nombre de passages × le nombre de candidats, plus les appels au juge, chacun posé deux fois. Avec 40 questions, 3 passages et 4 candidats, cela fait 480 appels, plus deux appels par comparaison confiée au juge. Le traitement par lots, à moitié prix chez Anthropic et OpenAI, s'y prête bien.

## Pour aller plus loin

- [La démarche](https://quelleia.com/demarche/)
- [Benchmarks et sources](https://quelleia.com/benchmarks/)
- [La démarche](https://quelleia.com/demarche/#marge)
- [Classement général](https://quelleia.com/classement/)
- [Mon classement, selon vos priorités](https://quelleia.com/mon-classement/)
- [Benchmark d'IA : ce qu'il mesure et pourquoi il sature](https://quelleia.com/guides/benchmark.md) (guide, amateur)
- [Lire le score de QUELLE IA : marge, rang et ex æquo](https://quelleia.com/guides/lire-le-score-quelle-ia.md) (guide, débutant)
- [Quel effort de réflexion choisir pour une IA, et quand](https://quelleia.com/guides/quel-effort-choisir.md) (guide, amateur)
- [Sorties structurées et appels d'outils : du JSON garanti](https://quelleia.com/guides/sorties-structurees-et-outils.md) (guide, nerd)

## Sources

- https://arxiv.org/abs/2306.05685 (lue le 17 novembre 2026)
- https://platform.claude.com/docs/en/build-with-claude/effort (lue le 17 novembre 2026)
- https://docs.ollama.com/capabilities/structured-outputs (lue le 17 novembre 2026)
- https://unsloth.ai/docs/get-started/fine-tuning-llms-guide (lue le 17 novembre 2026)
- https://platform.claude.com/docs/en/build-with-claude/batch-processing (lue le 17 novembre 2026)
- https://developers.openai.com/api/docs/guides/batch (lue le 17 novembre 2026)
