Przejdź do głównej treści
Polski— Wybierz język
Menu

Évaluations hors ligne : mesurez avant de déployer

Lekcja 14 z 16 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Passer des cas isolés à l’échelle
  2. Le modèle mental
  3. Une première évaluation
  4. Deux types d’évaluateurs
  5. Comparer les versions
  6. Définir des objectifs
  7. Kluczowe wnioski

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 SDK mistralai-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 du 3 novembre : mistralai-evaluations 0.9.1 nécessite mistralai < 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 là tout l’intérêt 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 TaskContext et produit une sortie — c’est le code que tu évalues
  • Évaluateurs : des fonctions qui reçoivent un ScorerContext et 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) pour 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 nécessaire, 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 de caractères ou un booléen ; le SDK produit alors une distribution de fréquences plutôt que des moyennes.

Comparer les 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 un garde-fou : une nouvelle version qui fait chuter un score en dessous de son objectif ne va pas en production.

Kluczowe wnioski

  • 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
  • System enregistre la configuration évaluée et permet la comparaison des versions
  • Les objectifs (Goal.gte, Goal.lte, Goal.between) fournissent des verdicts PASS ou FAIL