Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Giudici: Valutazione automatizzata degli LLM

Lezione 13 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Automatizzare la valutazione della qualità
  2. Due tipi di giudici
  3. Scrivere istruzioni efficaci
  4. Creare un giudice di classificazione tramite SDK
  5. Creare un giudice di regressione tramite SDK
  6. Convalidare prima di scalare
  7. Punti chiave

Lezione aggiornata il 2 novembre 2026 sulla base dell’SDK mistralai 3.7.0 e della pagina Evaluators di Mistral: judges.create richiede ora description e tools (gli esempi precedenti fallirebbero), gli output di regressione richiedono min_description e max_description, ed è possibile testare un giudice direttamente su una conversazione usando judge_conversation. Le variabili di modello e le “Campagne” delle versioni precedenti non compaiono più nella documentazione. Fonti: Evaluators · client-python.

Automatizzare la valutazione della qualità

Rivedere manualmente migliaia di conversazioni è impossibile su scala produttiva. I Giudici risolvono questo problema: sono valutatori basati su LLM che configuri una volta—definendo istruzioni, modello e formato di output—per poi applicarli a conversazioni o record di dataset. Ogni giudizio produce un’analisi e un verdetto: un’etichetta o un punteggio.

Due tipi di giudici

Classificazione

Un giudice di classificazione assegna etichette discrete a ogni risposta. Gli esempi includono:

  • Binario: helpful / not_helpful
  • Multiclasse: excellent / acceptable / poor
  • Categorizzazione: code_question / general_knowledge / troubleshooting
  • Sicurezza: safe / needs_review / unsafe

Regressione

Un giudice di regressione assegna un punteggio numerico all’interno di un intervallo, dove definisci tu i limiti:

  • Valutazione dell’utilità da 1 a 5
  • Punteggio di pertinenza da 0 a 100
  • Livello di confidenza da 0.0 a 1.0

Scrivere istruzioni efficaci

Le istruzioni del giudice determinano l’intera qualità della valutazione e la vaghezza è la causa principale di fallimento. Dire “Valuta la qualità della risposta” non significa nulla per un modello: ogni esecuzione interpreterà “qualità” in modo diverso. Una versione funzionante nomina criteri osservabili: “Valuta se la risposta risponde direttamente alla domanda posta, utilizzando informazioni fattualmente corrette”. Lo stesso principio vale per il contesto: il tuo giudice non sa di star valutando un chatbot di supporto dove “buono” significa “risolve il problema del cliente senza inviarlo alla documentazione”. Se non lo dichiari esplicitamente, applicherà una definizione generica di qualità che non è la tua.

I casi limite meritano un’attenzione speciale, poiché è qui che le valutazioni divergono. Specificare che “un punteggio di 3 significa che la risposta è parzialmente corretta ma manca di un elemento chiave” stabilizza il centro della tua scala: senza questo ancoraggio, la stessa conversazione potrebbe ricevere un 2, un 3 o un 4 a seconda dell’esecuzione. Il test definitivo è semplice: se due valutatori umani che leggono le tue istruzioni potrebbero non essere d’accordo su un dato caso, il tuo criterio è troppo vago e il giudice erediterà quell’ambiguità su larga scala.

Creare un giudice di classificazione tramite SDK

from mistralai.client import Mistral

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

# Giudice di classificazione a tre livelli
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}")

Creare un giudice di regressione tramite SDK

# Giudice di regressione: punteggio di utilità da 1 a 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}")

Convalidare prima di scalare

Un giudice non convalidato produce annotazioni false su larga scala. Prima di affidartici, testalo su conversazioni di cui conosci la risposta corretta: judge_conversation lo applica a un elenco di messaggi e restituisce la sua analisi e il verdetto.

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)  # Il ragionamento del giudice
print(result.answer)    # L'etichetta o il punteggio

Procedi poi metodicamente:

  1. Testa su 10-20 casi per i quali hai predeterminato il verdetto corretto
  2. Verifica la concordanza: il giudice produce gli stessi risultati tuoi?
  3. Testa la stabilità: rieseguendo sugli stessi casi, i risultati sono identici?
  4. Identifica i pattern di fallimento: su quali tipi di conversazioni il giudice sbaglia?

Se la concordanza è troppo bassa, affina le istruzioni prima di qualsiasi uso su larga scala. Una volta convalidato, un giudice si applica ai record del dataset (client.beta.observability.datasets.records.judge) e la stessa logica del giudice LLM appare nei valutatori per le valutazioni offline (Lezione 14).

Punti chiave

  • Un giudice LLM classifica (etichetta) o valuta (assegna un punteggio) le conversazioni, supportato da un’analisi
  • judges.create richiede name, description, model_name, instructions, output e tools
  • Un output di regressione definisce i suoi limiti (min_description, max_description)
  • Le istruzioni devono essere specifiche, contestualizzate e ancorate con esempi di punteggio
  • Convalida un giudice con judge_conversation su casi noti prima di farci affidamento