Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Judges: Geautomatiseerde LLM-evaluatie

Les 13 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Kwaliteitsevaluatie automatiseren
  2. Twee soorten judges
  3. Effectieve instructies schrijven
  4. Een classificatie-judge maken via de SDK
  5. Een regressie-judge maken via de SDK
  6. Valideren voordat u opschalt
  7. Belangrijkste punten

Les bijgewerkt op 2 november 2026 op basis van mistralai SDK 3.7.0 en de Mistral Evaluators-pagina: judges.create vereist nu description en tools (oudere voorbeelden zouden falen), regression-outputs vereisen min_description en max_description, en u kunt een judge direct testen op een conversatie met judge_conversation. Sjabloonvariabelen en “Campaigns” uit eerdere versies komen niet meer voor in de documentatie. Bronnen: Evaluators · client-python.

Kwaliteitsevaluatie automatiseren

Het handmatig beoordelen van duizenden conversaties is onmogelijk op productieschaal. Judges lossen dit probleem op: het zijn op LLM gebaseerde evaluatoren die u eenmaal configureert—door instructies, model en outputformaat te definiëren—en vervolgens toepast op conversaties of datasetrecords. Elke beoordeling levert een analyse en een oordeel op: een label of een score.

Twee soorten judges

Classificatie

Een classificatie-judge wijst discrete labels toe aan elk antwoord. Voorbeelden zijn:

  • Binair: helpful / not_helpful
  • Meerdere klassen: excellent / acceptable / poor
  • Categorisering: code_question / general_knowledge / troubleshooting
  • Veiligheid: safe / needs_review / unsafe

Regressie

Een regressie-judge wijst een numerieke score toe binnen een bereik, waarbij u de grenzen definieert:

  • Beoordeling van nuttigheid van 1 tot 5
  • Relevantiescore van 0 tot 100
  • Vertrouwensniveau van 0,0 tot 1,0

Effectieve instructies schrijven

De instructies van de judge bepalen de volledige kwaliteit van de evaluatie, en vaagheid is de primaire oorzaak van falen. “Evalueer de kwaliteit van het antwoord” betekent niets voor een model—elke uitvoering zal “kwaliteit” anders interpreteren. Een werkende versie noemt observeerbare criteria: “Evalueer of het antwoord de gestelde vraag direct beantwoordt, met feitelijk correcte informatie.” Hetzelfde principe geldt voor context: uw judge weet niet dat hij een support-chatbot evalueert waar “goed” betekent “lost het probleem van de klant op zonder ze naar de documentatie te sturen”. Als u dit niet expliciet vermeldt, past hij een generieke definitie van kwaliteit toe die niet de uwe is.

Randgevallen verdienen speciale aandacht, omdat evaluaties hier vaak uiteenlopen. Specificeren dat “een score van 3 betekent dat het antwoord gedeeltelijk correct is maar een sleutelelement mist”, stabiliseert het midden van uw schaal—zonder dit anker kan dezelfde conversatie een 2, 3 of 4 krijgen, afhankelijk van de uitvoering. De ultieme test is simpel: als twee menselijke evaluatoren die uw instructies lezen het oneens kunnen worden over een bepaald geval, is uw criterium te vaag, en zal de judge die ambiguïteit op schaal overnemen.

Een classificatie-judge maken via de SDK

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Classificatie-judge met drie niveaus
classifier = client.beta.observability.judges.create(
    name="Support Response Quality",
    description="Classifies each support chatbot response into three quality levels.",
    model_name="mistral-medium-latest",
    instructions="""
Evaluate the assistant's last response in the provided conversation.

Context: This is a technical support chatbot.

Criteria:
- Is the response factual and correct?
- Does it directly answer the question asked?
- Is the tone professional and empathetic?

Classify the response according to the proposed categories.
""",
    output={
        "type": "CLASSIFICATION",
        "options": [
            {"value": "excellent", "description": "Correct, complete, and professional response"},
            {"value": "acceptable", "description": "Correct but incomplete response, or tone needs improvement"},
            {"value": "poor", "description": "Incorrect, off-topic, or unprofessional response"},
        ],
    },
    tools=[],  # No tools for this judge
)

print(f"Judge created: {classifier.id}")

Een regressie-judge maken via de SDK

# Regressie-judge: Nuttigheidsscore van 1 tot 5
scorer = client.beta.observability.judges.create(
    name="Helpfulness Score",
    description="Rates the helpfulness of the assistant's last response on a scale of 1 to 5.",
    model_name="mistral-small-latest",
    instructions="""
Evaluate the helpfulness of the assistant's last response on a scale of 1 to 5.

1 = Useless (off-topic, incorrect, or does not answer the question)
2 = Slightly helpful (partially correct but misses the main point)
3 = Moderately helpful (correct but incomplete or too vague)
4 = Helpful (correct and sufficiently detailed)
5 = Very helpful (correct, detailed, with clear examples or steps)
""",
    output={
        "type": "REGRESSION",
        "min": 1,
        "max": 5,
        "min_description": "Useless response: off-topic, incorrect, or no answer provided",
        "max_description": "Very helpful response: correct, detailed, with clear steps",
    },
    tools=[],
)

print(f"Judge created: {scorer.id}")

Valideren voordat u opschalt

Een niet-gevalideerde judge produceert valse annotaties op schaal. Voordat u erop vertrouwt, test u deze op conversaties waarvan u het juiste antwoord kent: judge_conversation past deze toe op een lijst met berichten en retourneert de analyse en het oordeel.

result = client.beta.observability.judges.judge_conversation(
    judge_id=classifier.id,
    messages=[
        {"role": "user", "content": "My printer shows error E04, what should I do?"},
        {"role": "assistant", "content": "Check the documentation."},
    ],
)

print(result.analysis)  # De redenering van de judge
print(result.answer)    # Het label of de score

Ga vervolgens methodisch te werk:

  1. Test op 10 tot 20 gevallen waarvan u het juiste oordeel vooraf hebt bepaald
  2. Controleer overeenstemming: Produceert de judge dezelfde resultaten als u?
  3. Test stabiliteit: Zijn de resultaten identiek bij opnieuw uitvoeren op dezelfde gevallen?
  4. Identificeer faalpatronen: Bij welke soorten conversaties maakt de judge fouten?

Als de overeenstemming te laag is, verfijn dan de instructies voordat u grootschalig gebruik maakt van de judge. Zodra deze is gevalideerd, is een judge van toepassing op datasetrecords (client.beta.observability.datasets.records.judge), en verschijnt dezelfde LLM-judge-logica in de evaluatoren voor offline evaluaties (Les 14).

Belangrijkste punten

  • Een LLM-judge classificeert (labels) of scoort (beoordeelt) conversaties, ondersteund door een analyse
  • judges.create vereist name, description, model_name, instructions, output en tools
  • Een regression-output definieert zijn grenzen (min_description, max_description)
  • Instructies moeten specifiek, gecontextualiseerd en verankerd zijn met scorevoorbeelden
  • Valideer een judge met judge_conversation op bekende gevallen voordat u erop vertrouwt