Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Jeux de données : Construire des ensembles d'évaluation et itérer

Lektion 15 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Le dernier maillon de la boucle d’itération
  2. Structure d’un enregistrement
  3. Sources de données
  4. Révision et export
  5. Évaluer sur un jeu de données Studio
  6. Bonnes pratiques de gestion
  7. Viktiga punkter

Leçon réécrite le 2 novembre 2026 sur la base de la page Datasets de Mistral et du SDK mistralai 3.7.0 : un enregistrement contient un payload libre et des properties ; les jeux de données sont alimentés par saisie manuelle, import de fichier ou spans depuis l’Explorer, et transmis tels quels aux évaluations hors ligne. La méthode import_from_explorer de la version précédente n’existe plus. Sources : Datasets · Explore traces.

Le dernier maillon de la boucle d’itération

Un jeu de données est la collection de cas de test qui pilote une évaluation hors ligne. Il donne une mémoire à ton processus qualité : chaque incident observé en production peut devenir un cas de test, et chaque nouvelle version de l’application est mesurée contre lui. Sans jeu de données stable, tu compares des impressions ; avec lui, tu compares des chiffres.

Structure d’un enregistrement

Dans Studio, chaque enregistrement contient un payload — un objet JSON où tu définis les clés — et des properties, qui sont des métadonnées non transmises à la tâche évaluée. Lors d’une évaluation, le payload devient l’enregistrement d’entrée tel quel (ctx.input_record).

{"payload": {"ticket": "My October invoice lists the same subscription twice.", "category": "billing"}, "properties": {"source": "incident-2026-10-14"}}

Cette ligne représente également le format d’import JSONL pour les jeux de données Studio : un objet par ligne, contenant payload et properties.

Sources de données

Tu peux alimenter un jeu de données de plusieurs façons :

  • Saisie manuelle, dans Studio ou via l’API, enregistrement par enregistrement
  • Import de fichier JSONL utilisant le format ci-dessus
  • Depuis l’Explorer : une seule span, ou jusqu’à 500 spans sélectionnées, deviennent des enregistrements (Leçon 12)
  • Depuis le Playground Studio ou depuis un autre jeu de données
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")
datasets = client.beta.observability.datasets

# Créer le jeu de données
dataset = datasets.create(
    name="Support tickets — reference set",
    description="Manually validated ticket classification cases",
)
print(f"Dataset: {dataset.id} ({dataset.slug})")

# Ajouter des enregistrements
cases = [
    {"ticket": "I haven't been able to log in since this morning.", "category": "access"},
    {"ticket": "The PDF export crashes whenever the report exceeds 50 pages.", "category": "bug"},
]
for payload in cases:
    datasets.create_record(
        dataset_id=dataset.id,
        payload=payload,
        properties={"origin": "manual entry"},
    )

Pour les gros volumes, import_from_file importe un fichier JSONL déjà téléversé (via son file_id), et import_from_spans ingère des spans de trace : ces imports s’exécutent en tâches d’arrière-plan, et tu peux suivre leur progression avec fetch_task.

Révision et export

list_records itère sur les enregistrements page par page (page_size, page), et export_to_jsonl génère un export dont la réponse fournit l’URL de téléchargement (file_url) :

page = datasets.list_records(dataset_id=dataset.id, page_size=50, page=1)
export = datasets.export_to_jsonl(dataset_id=dataset.id)
print(export.file_url)

Évaluer sur un jeu de données Studio

Une évaluation hors ligne lit un jeu de données Studio par son slug ou son ID :

from mistralai.evaluations import Dataset, Evaluation, Evaluator, Project

run = await client.evaluation.run(
    project=Project(name="Ticket sorting"),
    evaluation=Evaluation(name="Reference set"),
    dataset=Dataset(slug="support-tickets-reference-set"),
    task=tache,
    evaluators=[Evaluator(name="exactitude", scorer=exactitude)],
)

Ici, client est le client SDK d’évaluation, et tache et exactitude sont définis dans la Leçon 14. Passe exactement l’un des deux : slug ou id ; sélectionner un jeu de données par son slug n’en crée jamais un nouveau. Garde deux règles en tête : une exécution lit les enregistrements présents au démarrage, jusqu’à 10 000 — un jeu de données n’est pas un instantané, donc le modifier n’affecte que les exécutions suivantes — et si des enregistrements sont ajoutés ou supprimés pendant la lecture, l’exécution échoue avant de démarrer plutôt que de s’exécuter sur un ensemble incohérent.

Bonnes pratiques de gestion

Conserve un ensemble de référence stable. Un jeu de données qui change à chaque exécution rend toute comparaison impossible. Crée un ensemble de référence que tu ne modifies que délibérément, et maintiens des jeux de données de travail séparés à côté.

Alimente-le depuis la production. Les cas les plus utiles sont ceux qui ont réellement causé des problèmes : une span repérée dans l’Explorer, où tu corriges la sortie attendue, vaut plus que dix cas inventés.

Documente la provenance. Les properties (origine, date, incident lié) ne sont pas vues par la tâche, mais elles te diront dans six mois pourquoi un cas existe.

Équilibre tes données. Un jeu de données contenant uniquement des cas faciles flatte ton système ; un autre contenant uniquement des pièges le décourage. Vise la distribution réelle de ton trafic, plus une poignée de cas limites reconnus.

Viktiga punkter

  • Un enregistrement de jeu de données = un payload (entrée de tâche) et des properties (métadonnées)
  • Saisie manuelle, import JSONL, spans de l’Explorer, Playground : plusieurs sources pour un seul jeu de données
  • Le SDK expose create, create_record, import_from_file, import_from_spans, list_records et export_to_jsonl
  • Les évaluations lisent un jeu de données via Dataset(slug=...) ou Dataset(id=...), jusqu’à 10 000 enregistrements
  • Un jeu de données n’est pas un instantané : conserve un ensemble de référence stable pour comparer les versions