Salt la conținutul principal
Română— Alege o limbă
Meniu

Judecători: Evaluarea automată a LLM-urilor

Lecția 13 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. Automatizarea evaluării calității
  2. Două tipuri de judecători
  3. Redactarea unor instrucțiuni eficiente
  4. Crearea unui judecător de clasificare prin SDK
  5. Crearea unui judecător de regresie prin SDK
  6. Validare înainte de scalare
  7. Puncte cheie

Lecție actualizată la 2 noiembrie 2026 pe baza SDK mistralai 3.7.0 și a paginii Mistral Evaluators: judges.create necesită acum description și tools (exemplele mai vechi ar eșua), ieșirile de tip regresie necesită min_description și max_description, iar puteți testa un judecător direct pe o conversație folosind judge_conversation. Variabilele de șablon și „Campaigns“ din versiunile anterioare nu mai apar în documentație. Surse: Evaluators · client-python.

Automatizarea evaluării calității

Revizuirea manuală a mii de conversații este imposibilă la scară de producție. Judecătorii rezolvă această problemă: sunt evaluatori bazați pe LLM pe care îi configurați o singură dată—definind instrucțiunile, modelul și formatul de ieșire—pentru a-i aplica apoi conversațiilor sau înregistrărilor din seturile de date. Fiecare judecată produce o analiză și un verdict: o etichetă sau un scor.

Două tipuri de judecători

Clasificare

Un judecător de clasificare atribuie etichete discrete fiecărui răspuns. Exemple includ:

  • Binare: helpful / not_helpful
  • Multiclase: excellent / acceptable / poor
  • Categorizare: code_question / general_knowledge / troubleshooting
  • Siguranță: safe / needs_review / unsafe

Regresie

Un judecător de regresie atribuie un scor numeric într-un interval definit de dumneavoastră:

  • Evaluarea utilității de la 1 la 5
  • Scorul de relevanță de la 0 la 100
  • Nivelul de încredere de la 0.0 la 1.0

Redactarea unor instrucțiuni eficiente

Instrucțiunile judecătorului determină întreaga calitate a evaluării, iar vaguitatea este cauza principală a eșecurilor. „Evaluează calitatea răspunsului“ nu înseamnă nimic pentru un model—fiecare execuție va interpreta „calitatea“ diferit. O versiune funcțională numește criterii observabile: „Evaluează dacă răspunsul răspunde direct la întrebarea pusă, folosind informații corecte din punct de vedere factual“. Același principiu se aplică contextului: judecătorul dumneavoastră nu știe că evaluează un chatbot de suport unde „bun“ înseamnă „rezolvă problema clientului fără a-l trimite la documentație“. Dacă nu precizați acest lucru explicit, el va aplica o definiție generică a calității care nu este a dumneavoastră.

Cazurile limită merită o atenție specială, deoarece aici diverg evaluările. Specificarea faptului că „un scor de 3 înseamnă că răspunsul este parțial corect, dar îi lipsește un element cheie“ stabilizează mijlocul scalei dumneavoastră—fără acest punct de ancorare, aceeași conversație ar putea primi un 2, 3 sau 4 în funcție de execuție. Testul suprem este simplu: dacă doi evaluatori umani care citesc instrucțiunile dumneavoastră ar putea fi în dezacord într-un caz dat, criteriul este prea vag, iar judecătorul va moșteni acea ambiguitate la scară largă.

Crearea unui judecător de clasificare prin SDK

from mistralai.client import Mistral

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

# Judecător de clasificare pe trei niveluri
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}")

Crearea unui judecător de regresie prin SDK

# Judecător de regresie: Scor de utilitate de la 1 la 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}")

Validare înainte de scalare

Un judecător nevalidat produce anotări false la scară largă. Înainte de a vă baza pe unul, testați-l pe conversații pentru care cunoașteți răspunsul corect: judge_conversation îl aplică unei liste de mesaje și returnează analiza și verdictul său.

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)  # Raționamentul judecătorului
print(result.answer)    # Eticheta sau scorul

Apoi, procedați metodic:

  1. Testați pe 10 până la 20 de cazuri pentru care ați predeterminat verdictul corect
  2. Verificați acordul: Produce judecătorul aceleași rezultate ca dumneavoastră?
  3. Testați stabilitatea: La rerularea acelorași cazuri, sunt rezultatele identice?
  4. Identificați tiparele de eșec: La ce tipuri de conversații greșește judecătorul?

Dacă acordul este prea scăzut, rafinați instrucțiunile înainte de orice utilizare la scară largă. Odată validat, un judecător se aplică înregistrărilor din seturile de date (client.beta.observability.datasets.records.judge), iar aceeași logică a judecătorului LLM apare în evaluatorii pentru evaluările offline (Lecția 14).

Puncte cheie

  • Un judecător LLM clasifică (etichetează) sau notează (evaluează) conversațiile, susținut de o analiză
  • judges.create necesită name, description, model_name, instructions, output și tools
  • O ieșire de tip regresie își definește limitele (min_description, max_description)
  • Instrucțiunile trebuie să fie specifice, contextualizate și ancorate cu exemple de scoruri
  • Validați un judecător cu judge_conversation pe cazuri cunoscute înainte de a vă baza pe el