Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

End-to-end pipeline: traces, judges, datasets, evaluations

Les 16 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Le flux de travail d’observabilité de bout en bout
  2. Implémentation en Python
  3. Résumé du cours
  4. Prochaines étapes recommandées
  5. Belangrijkste punten
  6. Testez vos connaissances

Leçon réécrite le 2 novembre 2026 sur la base de la documentation Observability de Mistral et du SDK mistralai 3.7.0 : le pipeline enchaîne désormais les traces, les juges, les jeux de données et les évaluations hors ligne. La fonctionnalité « Campaigns » ainsi que les méthodes chat_completion_events.search, campaigns.* et import_from_explorer de la version précédente n’existent plus. Sources : Explorer les traces · Évaluations hors ligne.

Le flux de travail d’observabilité de bout en bout

Vous maîtrisez désormais chaque composant de la pile d’observabilité de Mistral. Cette dernière leçon assemble ces pièces pour former un pipeline complet que vous pouvez reproduire et adapter à votre contexte de production.

1

Tracer et explorer

Activez la télémétrie, puis filtrez les traces des 7 derniers jours dans l'Explorer : erreurs, lenteurs, réponses suspectes. Notez l'expression de recherche.

2

Juger

Formalisez le critère de qualité en jeu dans un juge (classification ou régression), validé sur 10 à 20 cas connus.

3

Construire un jeu de données

Transformez les spans problématiques en enregistrements, avec la sortie attendue corrigée manuellement.

4

Évaluer

Mesurez la version actuelle, puis chaque variante, par rapport à ce jeu de données, avec des objectifs PASS/FAIL.

5

Itérer

Déployez la variante gagnante, conservez le jeu de données comme garde-fou de non-régression, et recommencez.

Implémentation en Python

Le script ci-dessous automatise les étapes 1, 3 et 4 ; le juge pour l’étape 2 est créé une seule fois, comme dans la leçon 13. Deux clients coexistent : le client SDK mistralai pour les traces et les jeux de données, et le client mistralai-evaluations pour l’évaluation.

import asyncio
import os
from datetime import datetime, timedelta, timezone

from mistralai.client import Mistral
from mistralai.evaluations import Dataset, Evaluation, Evaluator, Goal, Project, System
from mistralai.evaluations import Mistral as MistralEvaluations

key = os.environ["MISTRAL_API_KEY"]
api = Mistral(api_key=key)
evaluations = MistralEvaluations(api_key=key)

# 1. Identifier les traces en échec de la semaine
now = datetime.now(timezone.utc)
response = api.beta.observability.traces.search(
    from_=now - timedelta(days=7),
    to=now,
    search_expression="service_name = 'agent-support' AND status_code = 'Error'",
)
for trace in response.traces.results or []:
    print(trace.trace_id, trace.root_span_name)

# 3. Ajouter des cas revus et corrigés manuellement au jeu de données
corrected_cases = [
    {"ticket": "Payment refused even though my card is valid.", "category": "billing"},
    {"ticket": "Unable to add a colleague to my workspace.", "category": "access"},
]
dataset = api.beta.observability.datasets.create(
    name="Support incidents — week 44",
    description="Cases drawn from failed traces, expected output corrected",
)
for case in corrected_cases:
    api.beta.observability.datasets.create_record(dataset_id=dataset.id, payload=case)


# 4. Évaluer la version candidate (tâche et précision : voir leçon 14)
async def main():
    run = await evaluations.evaluation.run(
        project=Project(name="Ticket sorting"),
        evaluation=Evaluation(name="Week 44 non-regression"),
        system=System(name="medium-prompt-v2", params={
            "model": "mistral-medium-latest",
            "system_prompt": "Classify the ticket: access, billing, or bug. Reply with a single word.",
        }),
        dataset=Dataset(id=dataset.id),
        task=task,
        evaluators=[Evaluator(name="accuracy", scorer=accuracy, goal=Goal.gte(0.9))],
    )
    run.show(level="records")


asyncio.run(main())

Exécuté chaque semaine, ce script enrichit le jeu de données de non-régression avec des incidents réels, et chaque version candidate doit atteindre ses objectifs sur ce jeu de données avant déploiement.

Résumé du cours

Ce cours vous a guidé à travers quatre domaines essentiels pour la production d’IA avec Mistral :

Inférence par lots (Leçons 1-4)

Vous savez traiter des millions de requêtes à coût réduit, en utilisant le format JSONL, le lotissement de fichiers et le lotissement en ligne.

Sorties prédites (Leçons 5-7)

Vous savez réduire la latence de génération en fournissant une prédiction de sortie, notamment pour le code et l’édition de texte.

Citations et références (Leçons 8-10)

Vous savez ancrer les réponses de votre LLM dans des sources vérifiées, analyser les citations et construire des pipelines RAG fiables.

Observabilité (Leçons 11-16)

Vous savez tracer votre application avec OpenTelemetry, explorer les traces de production, automatiser l’évaluation de la qualité avec des juges, construire des jeux de données et mesurer chaque version via des évaluations hors ligne.

Prochaines étapes recommandées

La meilleure façon de consolider ces compétences est de les appliquer dans l’ordre qui profite le plus à votre environnement de production. Commencez par déployer un pipeline par lots sur un cas d’usage concret dans votre organisation — une classification mensuelle, un enrichissement de catalogue — car c’est le gain le plus rapide à démontrer. Ensuite, intégrez les Sorties prédites partout où vos outils modifient du code ou des documents existants : le gain de latence est mesurable en quelques jours. Ajoutez des citations à votre système RAG dès que les utilisateurs s’appuient sur ses réponses pour prendre des décisions. Enfin, l’observabilité commence par l’envoi de traces, ce qui est possible avec une simple clé API ; l’Explorer et les évaluations hors ligne nécessitent une organisation Enterprise. C’est l’offre Enterprise qui transformera ces trois premières initiatives en une boucle d’amélioration continue plutôt qu’en des déploiements ponctuels.

Belangrijkste punten

  • Le pipeline suit la boucle : tracer et explorer, juger, construire un jeu de données, évaluer, itérer
  • Chaque incident de production peut devenir un cas de test, et chaque version candidate doit atteindre ses objectifs
  • Automatisez la boucle avec le SDK (traces.search, datasets.create_record, evaluation.run) et exécutez-la à intervalles réguliers
  • Les quatre domaines de ce cours (lots, sorties prédites, citations, observabilité) se complètent pour une production d’IA robuste

Testez vos connaissances

Lots, latence, citations, observabilité : les quatre piliers de la production.

1. Quand l'inférence par lots est-elle le bon choix ?

Réponse : Pour les volumes élevés sans contraintes temps réel : jobs JSONL asynchrones (ou en ligne jusqu’à 10 000 requêtes) à coût réduit — classification, enrichissement, génération de masse.

2. Que sont les Sorties prédites ?

Réponse : Une accélération lorsque la réponse est largement prévisible (édition de texte existant, modèles) : vous fournissez la prédiction, et le modèle ne « paie » que pour les différences — la latence chute considérablement.

3. Que permettent les citations avec l'objet Reference ?

Réponse : Lier chaque affirmation de la réponse à ses sources dans un RAG : réponses vérifiables, hallucinations réduites — la confiance devient une propriété du produit.

4. Que faites-vous dans l'Explorer ?

Réponse : Rechercher et inspecter les traces de production — en utilisant un langage d’expression sur service_name, status_code, duration_ns ou les attributs de span — pour trouver les requêtes problématiques, puis les transformer en cas de test : la matière première de toute amélioration.

5. Comment les juges, les jeux de données et les évaluations fonctionnent-ils ensemble ?

Réponse : Les juges évaluent automatiquement (LLM-as-judge), les jeux de données accumulent des cas de test tirés de la production, et les évaluations hors ligne mesurent chaque version par rapport à ces jeux de données avec des objectifs PASS/FAIL — la boucle trace → juge → construction → évaluation.

Le pipeline final du cours enchaîne ces quatre éléments : produire économiquement, répondre rapidement, sourcer les réponses, observer — une production mature dans un seul flux de travail.