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

Pipeline end-to-end: spår, domare, datamängder, utvärderingar

Lektion 16 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Arbetsflödet för end-to-end-observability
  2. Python-implementering
  3. Sammanfattning av kursen
  4. Rekommenderade nästa steg
  5. Viktiga punkter
  6. Testa dina kunskaper

Lektionen omskriven den 2 november 2026 baserat på Mistrals dokumentation om Observability och mistralai SDK 3.7.0: pipeline:n länkar nu ihop spår, domare, datamängder och offline-utvärderingar. Funktionen “Campaigns” samt metoderna chat_completion_events.search, campaigns.* och import_from_explorer från tidigare versioner finns inte längre. Källor: Utforska spår · Offline-utvärderingar.

Arbetsflödet för end-to-end-observability

Du har nu bemästrat varje komponent i Mistrals observability-stack. Den här sista lektionen sätter ihop bitarna till en komplett pipeline som du kan reproducera och anpassa till din produktionsmiljö.

1

Spåra och utforska

Aktivera telemetri och filtrera sedan spår från de senaste 7 dagarna i Explorer: fel, långsamma svar, misstänkta responser. Notera sökuttrycket.

2

Bedöm (Judge)

Formalisera det aktuella kvalitetskriteriet till en domare (klassificering eller regression), validerad på 10 till 20 kända fall.

3

Bygg en datamängd

Omvandla problematiska span till poster, med förväntad output manuellt korrigerad.

4

Utvärdera

Mät den aktuella versionen och därefter varje variant mot denna datamängd, med mål för GODKÄND/UNDERKÄND (PASS/FAIL).

5

Iterera

Distribuera den vinnande varianten, behåll datamängden som ett skyddsnät mot regression och upprepa processen.

Python-implementering

Skriptet nedan automatiserar steg 1, 3 och 4; domaren för steg 2 skapas en gång, som i lektion 13. Två klienter samexisterar: mistralai SDK-klienten för spår och datamängder, samt mistralai-evaluations-klienten för utvärdering.

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. Identifiera misslyckade spår från veckan
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. Lägg till manuellt granskade och korrigerade fall i datamängden
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. Utvärdera kandidatversionen (uppgift och noggrannhet: se lektion 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())

När detta skript körs varje vecka växer datamängden för icke-regression med verkliga incidenter, och varje kandidatversion måste uppnå sina mål på denna datamängd innan distribution.

Sammanfattning av kursen

Den här kursen har lett dig genom fyra avgörande områden för AI-produktion med Mistral:

Batch-inferens (Lektion 1–4)

Du vet hur du bearbetar miljontals förfrågningar till reducerad kostnad, med JSONL-format, filbatchning och inline-batchning.

Predikterade output (Lektion 5–7)

Du vet hur du minskar genereringslatens genom att tillhandahålla en output-prediktion, särskilt för kod och textredigering.

Citat och referenser (Lektion 8–10)

Du vet hur du förankrar din LLM:s svar i verifierade källor, parser citat och bygger tillförlitliga RAG-pipeliner.

Observability (Lektion 11–16)

Du vet hur du spårar din applikation med OpenTelemetry, utforskar produktionsspår, automatiserar kvalitetsutvärdering med domare, bygger datamängder och mäter varje version via offline-utvärderingar.

Rekommenderade nästa steg

Det bästa sättet att befästa dessa färdigheter är att tillämpa dem i den ordning som gynnar din produktionsmiljö mest. Börja med att distribuera en batch-pipeline för ett konkret användningsfall i din organisation – en månatlig klassificering, en berikning av katalogen – eftersom det är den snabbaste vinsten att demonstrera. Integrera därefter Predikterade Output överallt där dina verktyg redigerar befintlig kod eller dokument: latensvinsten är mätbar inom dagar. Lägg till citat i ditt RAG-system så snart användare förlitar sig på dess svar för att fatta beslut. Slutligen börjar observability med att skicka spår, vilket är möjligt med en enkel API-nyckel; Explorer och offline-utvärderingar kräver en Enterprise-organisation. Det är Enterprise-nivån som kommer att omvandla de tre första initiativen till en loop för kontinuerlig förbättring snarare än engångsdistributioner.

Viktiga punkter

  • Pipeline:n följer loopen: spåra och utforska, bedöm (judge), bygg en datamängd, utvärdera, iterera
  • Varje produktionsincident kan bli ett testfall, och varje kandidatversion måste uppnå sina mål
  • Automatisera loopen med SDK:t (traces.search, datasets.create_record, evaluation.run) och kör den med jämna mellanrum
  • Kursens fyra områden (batch, predikterade output, citat, observability) kompletterar varandra för en robust AI-produktion

Testa dina kunskaper

Batch, latens, citat, observability: de fyra pelarna i produktion.

1. När är Batch-inferens rätt val?

Svar: För höga volymer utan krav på realtid: asynkrona JSONL-jobb (eller inline upp till 10 000 förfrågningar) till reducerad kostnad – klassificering, berikning, massgenerering.

2. Vad är Predikterade Output?

Svar: En acceleration när svaret till stor del är förutsägbart (redigering av befintlig text, mallar): du tillhandahåller prediktionen och modellen “betalar” bara för skillnaderna – latensen sjunker avsevärt.

3. Vad möjliggör citat med Reference Object?

Svar: Att länka varje påstående i svaret till dess källor i en RAG: verifierbara svar, minskade hallucinationer – tillit blir en produktegenskap.

4. Vad gör du i Explorer?

Svar: Söker och inspekterar produktionsspår – med hjälp av ett uttrycksspråk för service_name, status_code, duration_ns eller span-attribut – för att hitta problematiska förfrågningar och sedan omvandla dem till testfall: råmaterialet för alla förbättringar.

5. Hur samverkar domare, datamängder och utvärderingar?

Svar: Domare utvärderar automatiskt (LLM-as-judge), datamängder ackumulerar testfall hämtade från produktion, och offline-utvärderingar mäter varje version mot dessa datamängder med mål för GODKÄND/UNDERKÄND (PASS/FAIL) – loopen spår → bedöm → bygg → utvärdera.

Kursens slutgiltiga pipeline länkar samman alla fyra: producera ekonomiskt, svara snabbt, källhänvisa svar, observera – mogen produktion i ett enda arbetsflöde.