BroadRouter

Comment évaluer un LLM avant de changer de fournisseur

Par l’équipe BroadNet Inference · 5 min de lecture · Publié

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.

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, il s’agit d’une URL de base et d’un identifiant de modèle. La checklist de migration couvre cette partie, et la checklist de choix d’un fournisseur 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 servent à établir une présélection. Un petit jeu d’évaluation 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, 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 (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 :

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.

À 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 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.
  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 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, GLM 5.3 et 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, 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 liste ce qu’il faut tester. Les prix côte à côte sont sur la page de comparaison.

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 en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity