Przejdź do głównej treści
Polski— Wybierz język
Menu

Sędziowie: Zautomatyzowana ewaluacja LLM

Lekcja 13 z 16 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Automatyzacja oceny jakości
  2. Dwa typy sędziów
  3. Pisanie skutecznych instrukcji
  4. Tworzenie sędziego klasyfikacyjnego przez SDK
  5. Tworzenie sędziego regresyjnego przez SDK
  6. Walidacja przed skalowaniem
  7. Kluczowe wnioski

Lekcja zaktualizowana 2 listopada 2026 w oparciu o SDK mistralai w wersji 3.7.0 oraz stronę Mistral Evaluators: judges.create wymaga teraz pól description i tools (starsze przykłady nie zadziałają), wyniki regresji wymagają min_description i max_description, a sędziego możesz przetestować bezpośrednio na konwersacji za pomocą judge_conversation. Zmienne szablonu i „Kampanie“ z wcześniejszych wersji nie występują już w dokumentacji. Źródła: Evaluators · client-python.

Automatyzacja oceny jakości

Ręczne przeglądanie tysięcy konwersacji jest niemożliwe na skalę produkcyjną. Sędziowie rozwiązują ten problem: to ewaluatory oparte na LLM, które konfigurujesz raz – definiując instrukcje, model i format wyjścia – a następnie stosujesz do konwersacji lub rekordów zbioru danych. Każda ocena generuje analizę i werdykt: etykietę lub wynik liczbowy.

Dwa typy sędziów

Klasyfikacja

Sędzia klasyfikacyjny przypisuje każdej odpowiedzi dyskretne etykiety. Przykłady obejmują:

  • Binarna: helpful / not_helpful
  • Wieloklasowa: excellent / acceptable / poor
  • Kategoryzacja: code_question / general_knowledge / troubleshooting
  • Bezpieczeństwo: safe / needs_review / unsafe

Regresja

Sędzia regresyjny przypisuje wynik liczbowy w określonym zakresie, gdzie Ty definiujesz granice:

  • Ocena użyteczności od 1 do 5
  • Wynik trafności od 0 do 100
  • Poziom pewności od 0.0 do 1.0

Pisanie skutecznych instrukcji

Instrukcje sędziego decydują o całej jakości ewaluacji, a nieprecyzyjność jest główną przyczyną niepowodzeń. Zwrot „Oceń jakość odpowiedzi“ nic nie znaczy dla modelu – każde uruchomienie zinterpretuje słowo „jakość“ inaczej. Działająca wersja wskazuje obserwowalne kryteria: „Oceń, czy odpowiedź bezpośrednio odpowiada na zadane pytanie, używając faktograficznie poprawnych informacji“. Ta sama zasada dotyczy kontekstu: Twój sędzia nie wie, że ocenia chatbota wsparcia technicznego, gdzie „dobrze“ oznacza „rozwiązuje problem klienta bez odsyłania go do dokumentacji“. Jeśli nie zaznaczysz tego wyraźnie, zastosuje ogólną definicję jakości, która nie jest Twoja.

Przypadki brzegowe zasługują na szczególną uwagę, ponieważ to tam oceny zaczynają się rozbieżać. Określenie, że „wynik 3 oznacza odpowiedź częściowo poprawną, ale brakującą kluczowego elementu“, stabilizuje środek Twojej skali – bez tego kotwiczenia ta sama konwersacja może otrzymać 2, 3 lub 4 w zależności od uruchomienia. Ostateczny test jest prosty: jeśli dwaj ludzcy ewaluatorzy czytający Twoje instrukcje mogliby nie zgodzić się co do danego przypadku, Twoje kryterium jest zbyt niejasne, a sędzia odziedziczy tę niejednoznaczność na dużą skalę.

Tworzenie sędziego klasyfikacyjnego przez SDK

from mistralai.client import Mistral

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

# Sędzia klasyfikacyjny z trzema poziomami
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}")

Tworzenie sędziego regresyjnego przez SDK

# Sędzia regresyjny: Wynik użyteczności od 1 do 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}")

Walidacja przed skalowaniem

Niewalidowany sędzia generuje fałszywe adnotacje na dużą skalę. Zanim zaczniesz polegać na takim narzędziu, przetestuj je na konwersacjach, dla których znasz poprawną odpowiedź: judge_conversation stosuje sędziego do listy wiadomości i zwraca jego analizę oraz werdykt.

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)  # Uzasadnienie sędziego
print(result.answer)    # Etykieta lub wynik

Następnie postępuj metodycznie:

  1. Przetestuj na 10–20 przypadkach, dla których wcześniej określiłeś poprawny werdykt.
  2. Sprawdź zgodność: Czy sędzia generuje takie same wyniki jak Ty?
  3. Przetestuj stabilność: Czy przy ponownym uruchomieniu na tych samych przypadkach wyniki są identyczne?
  4. Zidentyfikuj wzorce błędów: Przy jakich typach konwersacji sędzia popełnia błędy?

Jeśli zgodność jest zbyt niska, dopracuj instrukcje przed jakimkolwiek zastosowaniem na dużą skalę. Po walidacji sędzia może być stosowany do rekordów zbioru danych (client.beta.observability.datasets.records.judge), a ta sama logika sędziego LLM pojawia się w ewaluatorach dla ocen offline (Lekcja 14).

Kluczowe wnioski

  • Sędzia LLM klasyfikuje (etykiety) lub ocenia (wyniki) konwersacje, wspierając się analizą.
  • judges.create wymaga pól: name, description, model_name, instructions, output oraz tools.
  • Wyjście regresyjne definiuje swoje granice (min_description, max_description).
  • Instrukcje muszą być szczegółowe, osadzone w kontekście i zakotwiczone przykładami wyników.
  • Zweryfikuj sędziego za pomocą judge_conversation na znanych przypadkach, zanim zaczniesz go używać.