Évaluations hors ligne : mesurez avant de déployer
På denna sida
Leçon réécrite le 2 novembre 2026 sur la base de la documentation Offline evaluations de Mistral : les « Campagnes » de la version précédente et leurs méthodes
campaigns.*n’existent plus. L’évaluation à grande échelle utilise désormais le SDKmistralai-evaluations, qui exécute une tâche sur un jeu de données, la note avec des évaluateurs et publie les résultats dans Studio. Sources : Offline evaluations · Evaluators · Goals. Mise à jour le 3 novembre :mistralai-evaluations0.9.1 nécessitemistralai< 3 et remplace le SDK 3.x par une version 2.x lors d’une installation conjointe ; la leçon recommande l’utilisation d’un environnement dédié (dépendances sur PyPI).
Passer des cas isolés à l’échelle
Un juge validé sur vingt conversations ne t’apprend rien sur ton application dans son ensemble. Pour décider si un nouveau prompt, un nouveau modèle ou un nouveau paramètre est meilleur que l’actuel, tu dois le mesurer sur un ensemble de cas représentatif et cohérent, puis comparer les résultats. C’est le rôle des évaluations hors ligne.
Elles sont réservées aux organisations Enterprise et nécessitent Python 3.12 ou ultérieur :
pip install mistralai-evaluations
Installe-le dans un environnement séparé. La version 0.9.1, la plus récente au 3 novembre 2026, requiert mistralai 2.x (mistralai>=2.7.1,<3). Dans un environnement contenant déjà le SDK 3.x, pip le désinstalle et installe une version 2.x, sans autre avertissement que ses lignes de sortie : vérifié avec mistralai 3.7.0, remplacé par 2.10.1. Un environnement virtuel dédié aux évaluations évite les régressions dans ton application.
Le modèle mental
Le SDK suit un flux simple :
Jeu de données → Tâche → Évaluateurs → Résultats
- Jeu de données : une liste d’enregistrements (dictionnaires) ou un jeu de données Studio
- Tâche : une fonction, de préférence asynchrone, qui reçoit un
TaskContextet produit une sortie — c’est le code que tu évalues - Évaluateurs : des fonctions qui reçoivent un
ScorerContextet notent chaque sortie - Résultats : statistiques et scores par enregistrement, affichés dans le terminal et publiés dans Studio
Une première évaluation
import asyncio
import os
from mistralai.evaluations import (
Evaluation, Evaluator, Goal, Mistral, Project, ScorerContext, System, TaskContext,
)
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
dataset = [
{"ticket": "I haven't been able to log in since this morning.", "categorie": "acces"},
{"ticket": "My October invoice charges the same subscription twice.", "categorie": "facturation"},
{"ticket": "The PDF export crashes as soon as the report exceeds 50 pages.", "categorie": "bug"},
]
async def tache(ctx: TaskContext) -> str:
response = await client.chat.complete_async(
model=str(ctx.system.params["model"]),
messages=[
{"role": "system", "content": str(ctx.system.params["system_prompt"])},
{"role": "user", "content": ctx.input_record["ticket"]},
],
)
return str(response.choices[0].message.content)
def exactitude(ctx: ScorerContext) -> int:
return 1 if ctx.input_record["categorie"] == str(ctx.output).strip().lower() else 0
async def main():
run = await client.evaluation.run(
project=Project(name="Tri des tickets"),
evaluation=Evaluation(name="Exactitude du classement"),
system=System(name="small-prompt-v1", params={
"model": "mistral-small-latest",
"system_prompt": "Classe le ticket : acces, facturation ou bug. Réponds par le seul mot.",
}),
dataset=dataset,
task=tache,
evaluators=[
Evaluator(
name="exactitude",
description="1 si la catégorie prédite est la bonne, 0 sinon.",
scorer=exactitude,
goal=Goal.gte(0.8),
),
],
)
run.show(level="records")
asyncio.run(main())
Les résultats s’affichent dans le terminal et sont publiés dans Studio sous Observability > Evaluate > Evaluations. Le SDK calcule la moyenne, le minimum, le maximum et l’écart-type pour chaque évaluateur.
Privilégie une tâche asynchrone pour les processus longs : une tâche synchrone s’exécute sur la boucle d’événements qui envoie également les signaux de maintien (heartbeat) de l’exécution vers Studio, et un appel bloqué pendant plusieurs minutes peut entraîner le marquage de l’exécution comme annulée.
Deux types d’évaluateurs
Un évaluateur associe un nom, une description optionnelle, une fonction de notation et, si besoin, un objectif. La fonction peut être :
- Basée sur des règles : un calcul direct sur la sortie — exact, rapide et gratuit ;
- Un juge LLM : une fonction qui appelle un modèle pour noter ce qui est difficile à coder — utilité, exactitude factuelle, ton.
JUDGE_PROMPT = """Tu es un correcteur exigeant. Note de 0 à 5 l'utilité de la réponse
pour la request ci-dessous. Réponds par le seul chiffre.
Demande : {request}
Réponse : {response}
"""
def judge_utility(ctx: ScorerContext) -> int:
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": JUDGE_PROMPT.format(
request=ctx.input_record["ticket"], response=ctx.output)}],
temperature=0,
)
raw = str(response.choices[0].message.content).strip()
return int(raw[0]) if raw[:1].isdigit() else 0
Tu peux librement mélanger les deux types dans une seule exécution : passe-les ensemble dans la liste evaluators. Un évaluateur peut aussi renvoyer une chaîne ou un booléen ; le SDK produit alors une distribution de fréquences plutôt que des moyennes.
Comparer des versions
L’objet System capture la configuration de la tâche : modèle, température, prompt système ou tout autre paramètre, dans un dictionnaire libre. Chaque exécution enregistre son System, et Studio te permet de comparer les exécutions côte à côte. Pour choisir entre deux prompts ou deux modèles, relance la même évaluation avec deux objets System différents, sans toucher au code de la tâche.
Définir des objectifs
Un objectif transforme un score en verdict PASS ou FAIL : Goal.gte(0.8) exige une moyenne d’au moins 0,8, Goal.lte(...) fixe un plafond, et Goal.between(...) définit une plage. Chaque objectif cible la moyenne par défaut, ou une autre statistique via metric ("min", "max", "std") : Goal.gte(0.8, metric="min") exige que chaque enregistrement atteigne 0,8. C’est ce qui fait d’une évaluation une garde-fou : une nouvelle version qui fait chuter un score en dessous de son objectif ne va pas en production.
Viktiga punkter
- Les évaluations hors ligne (
mistralai-evaluations, Python 3.12+, organisations Enterprise) remplacent les anciennes Campagnes - Jeu de données, tâche, évaluateurs, résultats :
client.evaluation.run(...)enchaîne le tout et publie dans Studio - Les évaluateurs sont des fonctions : règles exactes ou juges LLM, librement combinés
Systemenregistre la configuration évaluée et permet la comparaison de versions- Les objectifs (
Goal.gte,Goal.lte,Goal.between) fournissent des verdicts PASS ou FAIL