---
title: "Évaluer un LLM avant de changer : jeu d’éval et LLM juge"
description: "Construisez un petit jeu d’évaluation à partir du trafic réel, notez-le avec des tests en code et un LLM juge débiaisé, puis comparez qualité, coût et latence."
url: https://broadrouter.com/fr/blog/evaluate-llm-before-switching/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/evaluate-llm-before-switching/) (mis à jour le 2026-11-14).

# Comment évaluer un LLM avant de changer de fournisseur

Par l’équipe BroadNet Inference · 5 min de lecture · Publié 2026-11-14

Rassemblez 50 à 200 prompts réels dont vous connaissez le bon résultat. Notez les deux modèles d’abord avec des tests en code, et avec un LLM juge seulement là où le code ne peut pas trancher. Inversez l’ordre des réponses pour neutraliser le biais de position, prenez un juge d’une troisième famille de modèles, comparez-le à vos propres annotations et fixez la règle de réussite, coût et latence compris, avant de lancer.

## À retenir

-   Construisez le jeu d’évaluation à partir de vrais journaux, pas de prompts inventés, et incluez les cas difficiles et ceux qui échouent.
-   Privilégiez les tests déterministes (le JSON se parse, le champ est égal, le test passe). N’utilisez un LLM juge que pour les qualités que le code ne peut pas vérifier.
-   Les LLM juges ont des biais de position, de longueur et d’autopréférence. Jugez chaque paire deux fois en inversant l’ordre.
-   Avec 100 cas, un score de 80 % a une marge à 95 % d’environ ±8 points. Les petites différences sont du bruit.
-   Fixez la règle de réussite à l’avance, en incluant coût, latence et aucune régression sur les cas critiques.

**Sur cette page**

1.  Comment construire un jeu d’évaluation à partir du trafic réel ?
2.  Quels tests confier au code, et lesquels à un juge ?
3.  Qu’est-ce qui peut mal tourner avec un LLM juge ?
4.  Comment mener une comparaison côte à côte ?
5.  À partir de quel écart une différence est-elle réelle ?
6.  Quelle règle de décision adopter ?
7.  La place de BroadNet Inference

Pour évaluer un LLM avant de changer, faites tourner les deux modèles sur 50 à 200 prompts réels dont vous connaissez le bon résultat. Notez d’abord avec des tests en code, et avec un LLM juge débiaisé seulement là où le code ne peut pas trancher ; journalisez coût et latence, et fixez la règle de réussite à l’avance.

Le changement de code lui-même est minime : avec une [API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/), il s’agit d’une [URL de base](https://broadrouter.com/fr/glossary/base-url/) et d’un identifiant de modèle. La [checklist de migration](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/) couvre cette partie, et la [checklist de choix d’un fournisseur](https://broadrouter.com/fr/blog/choose-llm-api-provider-checklist/) couvre prix, limites et confidentialité. Le plus difficile est de savoir si le nouveau modèle est aussi bon **pour vos tâches**. Les classements publics ne répondent pas à cette question ; [Artificial Analysis et ses alternatives](https://broadrouter.com/fr/blog/artificial-analysis-alternatives/) servent à établir une présélection. Un petit jeu d’[évaluation](https://broadrouter.com/fr/glossary/eval/) construit à partir de votre propre trafic y répond, en un ou deux jours de travail.

## Comment construire un jeu d’évaluation à partir du trafic réel ?

1.  **Extrayez 300 à 1 000 requêtes récentes** de vos [journaux d’usage](https://broadrouter.com/fr/blog/llm-api-usage-logging/), après caviardage.
2.  **Regroupez-les par type de tâche** : extraction, classification, résumé, réponse de chat, modification de code, appel d’outil.
3.  **Échantillonnez 10 à 40 cas par type**, davantage pour les types à fort volume ou à risque élevé. Incluez de longs prompts, des entrées non anglaises et les cas dont les utilisateurs se sont plaints.
4.  **Écrivez le résultat attendu** pour chacun : une valeur exacte, un schéma, un test qui doit passer ou une courte grille (« mentionne le délai de remboursement ; aucune règle inventée »).
5.  **Marquez les cas critiques.** Un total de facture faux ou une instruction divulguée n’a rien à voir avec un ton un peu moins bon.
6.  **Figez le jeu** dans votre gestionnaire de versions. Ajoutez des cas quand vous trouvez de nouveaux échecs, et n’en supprimez jamais pour faire paraître un modèle meilleur.

## Quels tests confier au code, et lesquels à un juge ?

Utilisez pour chaque cas le test fiable le moins coûteux :

| Tâche | Test | Juge nécessaire ? |
| --- | --- | --- |
| Extraction JSON | Se parse, le schéma valide, les champs sont égaux à l’attendu | Non |
| Classification | Le label est égal à l’attendu | Non |
| Modification de code | Les tests passent | Non |
| Appel d’outil | Bonne fonction, arguments valides | Non |
| Résumé | Contient les faits requis ; aucun fait absent de la source | Parfois |
| Réponse de chat, ton, utilité | Grille | Oui |

Les tests déterministes sont gratuits, reproductibles et insensibles à la flatterie : faites passer autant de cas que possible par des tests en code.

## Qu’est-ce qui peut mal tourner avec un LLM juge ?

Un [LLM juge](https://broadrouter.com/fr/glossary/llm-as-judge/) (LLM-as-a-judge) est un modèle qui note les réponses d’autres modèles selon une grille. L’étude MT-Bench (Zheng et al.) a montré que les juges performants étaient d’accord avec les préférences humaines dans plus de 80 % des cas, à peu près aussi souvent que les humains entre eux. Le même article nomme les biais dont il faut tenir compte :

| Biais | Ce qui se passe | Parade |
| --- | --- | --- |
| Position | Préfère la première (ou la seconde) réponse affichée | Juger chaque paire deux fois, ordre inversé ; compter une victoire seulement si les deux concordent |
| Longueur | Préfère les réponses plus longues | Grille qui récompense l’exactitude et la concision ; limiter la longueur dans le prompt |
| Autopréférence | Préfère les réponses dans son propre style | Juge d’une autre famille de modèles que les deux candidats |
| Raisonnement faible | Manque les erreurs de maths ou de code | Utiliser plutôt des tests en code pour ces cas |

Deux règles de plus, tirées de la pratique. **Figez le juge** : même version du modèle, même prompt, température 0, pendant toute la comparaison. Et **calibrez-le** : annotez vous-même 30 à 50 paires, faites-les juger, et ne lui faites confiance que s’il est d’accord avec vous la plupart du temps. Le guide des évaluateurs d’Arize donne le même conseil (« Collect 20–100 examples », traduction : « Rassemblez 20 à 100 exemples ») avec des annotations humaines, et recommande des labels catégoriels comme pass/fail plutôt que de grandes échelles numériques.

## Comment mener une comparaison côte à côte ?

Faites tourner les deux candidats sur chaque cas, masquez leur identité au juge, inversez l’ordre et journalisez coût et temps :

```python
import os, random, time, json
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
A, B = "broadnet/deepseek-v4.1-flash", "broadnet/qwen3.8-27b"
JUDGE = "broadnet/glm-5.3"  # a third family, pinned

def run(model, case):
    t0 = time.perf_counter()
    r = client.chat.completions.create(model=model, messages=case["messages"], max_tokens=4000, temperature=0)
    return {"text": r.choices[0].message.content or "", "usage": r.usage.model_dump(),
            "secs": time.perf_counter() - t0}

def judge(case, first, second):
    prompt = (f"Task:\n{case['task']}\n\nRubric:\n{case['rubric']}\n\n"
              f"Answer 1:\n{first}\n\nAnswer 2:\n{second}\n\n"
              'Reply with JSON only: {"winner": 1 or 2 or 0 for tie, "reason": "..."}')
    r = client.chat.completions.create(model=JUDGE, temperature=0, max_tokens=2000,
                                       response_format={"type": "json_object"},
                                       messages=[{"role": "user", "content": prompt}])
    return int(json.loads(r.choices[0].message.content or "{}").get("winner", 0))

def compare(case):
    a, b = run(A, case), run(B, case)
    if case.get("check"):                       # deterministic first
        return {"a_ok": case["check"](a["text"]), "b_ok": case["check"](b["text"]), "a": a, "b": b}
    w1 = judge(case, a["text"], b["text"])      # A shown first
    w2 = judge(case, b["text"], a["text"])      # B shown first
    winner = "A" if (w1, w2) == (1, 2) else "B" if (w1, w2) == (2, 1) else "tie"
    return {"winner": winner, "a": a, "b": b}
```

Avec la règle d’inversion, un modèle ne gagne que si le juge le préfère dans les deux positions ; tout désaccord compte comme une égalité. La part de désaccords est elle-même utile : un taux élevé signifie que le juge ou la grille est trop vague. Notez le `max_tokens=4000` : sur les modèles de raisonnement, la réflexion compte dans la limite, et un plafond bas produit des réponses vides qui ressemblent à des échecs. Voir [pourquoi les modèles de raisonnement renvoient des réponses vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).

## À partir de quel écart une différence est-elle réelle ?

Les scores d’évaluation sont des échantillons. Pour un taux de réussite p sur n cas, l’erreur type vaut √(p × (1 − p) ÷ n), et une marge à 95 % en vaut environ le double.

| Cas | Taux de réussite | Marge à 95 % |
| --- | --- | --- |
| 50 | 80 % | environ ±11 points |
| 100 | 80 % | environ ±8 points |
| 200 | 80 % | environ ±6 points |
| 400 | 80 % | environ ±4 points |

Un modèle à 82 % contre 79 % sur 100 cas n’a donc pas prouvé qu’il était meilleur. Regardez plutôt les **différences cas par cas** : quels cas sont passés de réussite à échec ? Ils en disent plus que les totaux, et sur les cas critiques, une seule bascule peut décider du changement.

## Quelle règle de décision adopter ?

Écrivez-la avant de lancer l’évaluation, pour que le résultat ne puisse pas l’infléchir. Un modèle pratique :

1.  Aucune régression sur un cas marqué critique.
2.  Taux de réussite global pas inférieur à celui du modèle actuel de plus que la marge d’erreur.
3.  Latence p95 dans votre budget ; voir [TTFT ou débit](https://broadrouter.com/fr/blog/llm-latency-ttft-throughput/) pour savoir comment la mesurer.
4.  Coût par cas réussi plus bas, ou plus élevé seulement d’un montant dont vous avez convenu qu’il vaut le gain de qualité. Chiffrez l’écart mensuel avec le [calculateur de coût d’API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).
5.  Une période en mode fantôme : envoyez une part du trafic réel au nouveau modèle, journalisez les deux et comparez avant de basculer.

Le même jeu d’évaluation est le point de départ si vous envisagez un modèle sur mesure : [avant le fine-tuning](https://broadrouter.com/fr/blog/fine-tuning-readiness/) explique quand les prompts et la recherche documentaire suffisent.

## La place de BroadNet Inference

BroadNet Inference sert plusieurs familles de modèles derrière un même endpoint compatible OpenAI, dont [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) et [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) : les candidats et un juge d’une autre famille peuvent donc passer par le même client et la même clé. Chaque réponse indique la consommation de tokens pour comparer les coûts, et les nouveaux comptes commencent avec $5 de crédit ; sans recharge, ce crédit ne couvre que [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/), prévoyez donc une petite recharge pour comparer les modèles plus grands. Il n’inclut ni harnais d’évaluation ni outil de juge hébergé ; c’est vous qui exécutez le code ci-dessus. Pour les charges de travail en arabe, [choisir un LLM pour l’arabe](https://broadrouter.com/fr/blog/choosing-an-llm-for-arabic/) liste ce qu’il faut tester. Les prix côte à côte sont sur la [page de comparaison](https://broadrouter.com/compare/).

Outils gratuits sur ce sujet (en anglais)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/)

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

[LLM-as-a-judge (LLM juge)](https://broadrouter.com/fr/glossary/llm-as-judge/)

LLM-as-a-judge est une méthode d’évaluation dans laquelle un modèle de langage note les sorties d’autres modèles, soit en évaluant une réponse unique selon une grille, soit en choisissant la meilleure de deux réponses. Elle approche le jugement humain pour un coût bien moindre, mais présente des biais connus, comme une préférence pour la première réponse ou la plus longue.

[Eval (évaluation de LLM)](https://broadrouter.com/fr/glossary/eval/)

Une eval (abréviation d’évaluation) est un test reproductible d’un modèle de langage ou d’un prompt : un ensemble fixe d’entrées, une description de ce qu’est une bonne sortie et un correcteur (du code, un humain ou un autre modèle) qui note chaque sortie pour pouvoir comparer les versions.

[Crédit prépayé (prepaid credit)](https://broadrouter.com/fr/glossary/prepaid-credit/)

Le crédit prépayé est de l’argent versé sur un compte API avant utilisation. Chaque requête déduit son coût du solde, et quand le solde est épuisé, les requêtes facturées s’arrêtent jusqu’à la prochaine recharge. Les dépenses sont ainsi plafonnées à ce que vous avez versé.

[Fine-tuning (affinage d’un modèle)](https://broadrouter.com/fr/glossary/fine-tuning/)

Le fine-tuning consiste à poursuivre l’entraînement d’un modèle de langage pré-entraîné sur un jeu de données plus petit et propre à une tâche, comme des conversations d’exemple, pour que ses poids changent et qu’il exécute cette tâche ou ce style de façon plus fiable, sans longues instructions ni exemples dans chaque prompt.

[Latence (LLM)](https://broadrouter.com/fr/glossary/latency/)

Pour une API de modèle de langage, la latence est le temps que prend une requête entre son envoi et la réception du dernier token de sortie. C’est la somme du time to first token et du temps de génération, généralement exprimée en percentiles comme le p50 et le p95 plutôt qu’en moyenne.

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

## Questions fréquentes

### Combien d’exemples faut-il dans un jeu d’évaluation de LLM ?

Cinquante suffisent pour repérer les grosses régressions, 200 pour voir des écarts de l’ordre de 5 à 10 points. La couverture compte plus que la taille : incluez chaque type de tâche et vos cas d’échec connus.

### Le LLM juge (LLM-as-a-judge) est-il fiable ?

En partie. Dans l’étude MT-Bench, les juges performants étaient d’accord avec les préférences humaines dans plus de 80 % des cas, à peu près aussi souvent que les humains entre eux. Ils montraient aussi des biais de position, de longueur et d’auto-valorisation : débiaisez-les et vérifiez-les par sondage.

### Le modèle juge doit-il être le même que le modèle testé ?

Non. Les juges ont tendance à favoriser les réponses qui ressemblent aux leurs. Prenez un juge d’une autre famille de modèles et figez-le sur une seule version pendant toute la comparaison.

### Qu’est-ce que le biais de position dans l’évaluation des LLM ?

Le juge préfère la réponse affichée en premier, ou en second, quelle que soit sa qualité. Corrigez-le en jugeant chaque paire deux fois avec l’ordre inversé et en ne comptant une victoire que si les deux ordres concordent.

### Faut-il comparer coût et latence dans la même évaluation ?

Oui. Journalisez les tokens et le temps de chaque appel d’évaluation. Un modèle qui gagne deux points mais coûte ou répond trois fois plus lentement peut quand même être un mauvais choix.

## À lire ensuite

-   [Comment choisir un fournisseur d’API LLM : checklist en 20 points](https://broadrouter.com/fr/blog/choose-llm-api-provider-checklist/)
-   [Passer à une API compatible OpenAI : la checklist de migration](https://broadrouter.com/fr/blog/openai-compatible-api-migration-checklist/)
-   [Choisir une API LLM pour l’arabe : ce qu’il faut tester](https://broadrouter.com/fr/blog/choosing-an-llm-for-arabic/)
-   [Journaliser l’usage d’une API LLM : coût par utilisateur, sans PII](https://broadrouter.com/fr/blog/llm-api-usage-logging/)
-   [Latence LLM : TTFT, tokens par seconde et temps de bout en bout](https://broadrouter.com/fr/blog/llm-latency-ttft-throughput/)
-   [Avant le fine-tuning : définir le problème à résoudre](https://broadrouter.com/fr/blog/fine-tuning-readiness/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-evaluate-llm-before-switching&utm_content=page-cta) ·

**Sources**

-   [Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, arXiv 2306.05685 (consulté le 2026-11-14)](https://arxiv.org/abs/2306.05685)
-   [Documentation d’Arize, bonnes pratiques pour les évaluateurs (consultée le 2026-11-14)](https://arize.com/docs/ax/concepts/evaluators/evaluator-best-practices)
-   [Référence de l’API de BroadNet Inference (consultée le 2026-11-14) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-evaluate-llm-before-switching&utm_content=sources)
-   [Prix lisibles par machine de BroadNet Inference, pricing.json (consultés le 2026-11-14) (en anglais)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-evaluate-llm-before-switching&utm_content=sources)
