---
title: "Valutare un LLM prima di cambiare: eval set e LLM judge"
description: "Crea un piccolo eval set dal traffico reale, valutalo con controlli nel codice e un LLM judge senza bias, e confronta qualità, costo e latenza prima di migrare."
url: https://broadrouter.com/it/blog/evaluate-llm-before-switching/
lang: it
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/evaluate-llm-before-switching/) (aggiornato il 2026-11-14).

# Come valutare un LLM prima di cambiare provider

A cura del team di BroadNet Inference · 5 min di lettura · Pubblicato 2026-11-14

Raccogli da 50 a 200 prompt reali con un esito corretto noto. Valuta entrambi i modelli prima con controlli nel codice e usa un LLM judge solo dove il codice non può decidere. Inverti l’ordine delle risposte per annullare il bias di posizione, usa un giudice di una terza famiglia di modelli, verificalo sulle tue etichette e fissa la regola di promozione, costo e latenza compresi, prima di eseguirlo.

## Punti chiave

-   Costruisci l’eval set dai log reali, non da prompt inventati, e includi i casi difficili e quelli che falliscono.
-   Preferisci i controlli deterministici (il JSON si parsa, il campo è uguale, il test passa). Usa un LLM judge solo per le qualità che il codice non può verificare.
-   Gli LLM judge mostrano bias di posizione, di verbosità e di autopreferenza. Giudica ogni coppia due volte invertendo l’ordine.
-   Con 100 casi, un punteggio dell’80% ha un margine al 95% di circa ±8 punti. Le piccole differenze sono rumore.
-   Decidi in anticipo la regola di promozione, compresi costo, latenza e nessuna regressione sui casi critici.

**In questa pagina**

1.  Come si costruisce un eval set dal traffico reale?
2.  Quali controlli vanno nel codice e quali a un giudice?
3.  Cosa va storto con l’LLM-as-a-judge?
4.  Come si fa un confronto fianco a fianco?
5.  Quanto deve essere grande una differenza per essere reale?
6.  Quale deve essere la regola di decisione?
7.  Dove si colloca BroadNet Inference

Per valutare un LLM prima di cambiare, esegui entrambi i modelli su 50–200 prompt reali con un esito corretto noto. Valuta prima con controlli nel codice e usa un LLM judge senza bias solo dove il codice non può decidere, registra costo e latenza e fissa in anticipo la regola di promozione.

La modifica al codice in sé è piccola: con un’[API compatibile con OpenAI](https://broadrouter.com/it/glossary/openai-compatible-api/) sono una [base URL](https://broadrouter.com/it/glossary/base-url/) e un ID di modello. La [checklist di migrazione](https://broadrouter.com/it/blog/openai-compatible-api-migration-checklist/) copre quella parte, e la [checklist per scegliere il provider](https://broadrouter.com/it/blog/choose-llm-api-provider-checklist/) copre prezzo, limiti e privacy. La parte difficile è capire se il nuovo modello è altrettanto valido **per i tuoi task**. Le classifiche pubbliche non rispondono a questa domanda; [Artificial Analysis e le sue alternative](https://broadrouter.com/it/blog/artificial-analysis-alternatives/) servono a fare una rosa di candidati. Un piccolo set di [eval](https://broadrouter.com/it/glossary/eval/) costruito dal tuo traffico sì, con uno o due giorni di lavoro.

## Come si costruisce un eval set dal traffico reale?

1.  **Estrai da 300 a 1.000 richieste recenti** dai tuoi [log di utilizzo](https://broadrouter.com/it/blog/llm-api-usage-logging/), dopo averle oscurate.
2.  **Raggruppale per tipo di task**: estrazione, classificazione, riassunto, risposta in chat, modifica di codice, tool call.
3.  **Campiona da 10 a 40 casi per tipo**, di più per i tipi ad alto volume o ad alto rischio. Includi prompt lunghi, input non in inglese e i casi di cui gli utenti si sono lamentati.
4.  **Scrivi l’esito atteso** per ciascuno: un valore esatto, uno schema, un test che deve passare o una breve rubrica («cita la finestra per il rimborso; nessuna policy inventata»).
5.  **Etichetta i casi critici.** Un totale di fattura sbagliato o un’istruzione trapelata non equivalgono a un tono un po’ peggiore.
6.  **Congelalo** sotto controllo di versione. Aggiungi casi quando trovi nuovi errori, non eliminarli mai per far sembrare migliore un modello.

## Quali controlli vanno nel codice e quali a un giudice?

Usa per ogni caso il controllo affidabile più economico:

| Task | Controllo | Serve un giudice? |
| --- | --- | --- |
| Estrazione JSON | Si parsa, lo schema è valido, i campi corrispondono all’atteso | No |
| Classificazione | L’etichetta corrisponde all’attesa | No |
| Modifica di codice | I test passano | No |
| Tool call | Funzione giusta, argomenti validi | No |
| Riassunto | Contiene i fatti richiesti; nessun fatto assente dalla fonte | A volte |
| Risposta in chat, tono, utilità | Rubrica | Sì |

I controlli deterministici sono gratuiti, ripetibili e impossibili da lusingare, quindi sposta nei controlli via codice quanti più casi puoi.

## Cosa va storto con l’LLM-as-a-judge?

Un [LLM-as-a-judge](https://broadrouter.com/it/glossary/llm-as-judge/) è un modello che valuta le risposte di altri modelli secondo una rubrica. Lo studio MT-Bench (Zheng et al.) ha rilevato che i giudici forti concordavano con le preferenze umane in oltre l’80% dei casi, più o meno quanto gli esseri umani concordano tra loro. Lo stesso articolo ha individuato i bias di cui devi tenere conto nel progetto:

| Bias | Cosa succede | Rimedio |
| --- | --- | --- |
| Posizione | Preferisce la prima (o la seconda) risposta mostrata | Giudica ogni coppia due volte, con l’ordine invertito; conta una vittoria solo se i due giudizi concordano |
| Verbosità | Preferisce le risposte più lunghe | Rubrica che premia correttezza e concisione; limita la lunghezza nel prompt |
| Autopreferenza | Preferisce le risposte nel proprio stile | Giudice di una famiglia di modelli diversa da entrambi i candidati |
| Ragionamento debole | Non vede errori di matematica o di codice | Per quei casi usa invece controlli nel codice |

Altre due regole dalla pratica. **Fissa il giudice**: stessa versione del modello, stesso prompt, temperatura 0, per tutto il confronto. E **calibralo**: etichetta tu stesso da 30 a 50 coppie, esegui il giudice su quelle e fidati solo se concorda con te nella maggior parte dei casi. La guida agli evaluator di Arize dà lo stesso consiglio («Collect 20–100 examples», traduzione: «Raccogli 20–100 esempi», con etichette umane) e raccomanda etichette categoriali come pass/fail invece di ampie scale numeriche.

## Come si fa un confronto fianco a fianco?

Esegui entrambi i candidati su ogni caso, nascondi al giudice chi è chi, inverti l’ordine e registra costo e tempi:

```python
import os, random, time, json
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
A, B = "broadnet/deepseek-v4.1-flash", "broadnet/qwen3.8-27b"
JUDGE = "broadnet/glm-5.3"  # a third family, pinned

def run(model, case):
    t0 = time.perf_counter()
    r = client.chat.completions.create(model=model, messages=case["messages"], max_tokens=4000, temperature=0)
    return {"text": r.choices[0].message.content or "", "usage": r.usage.model_dump(),
            "secs": time.perf_counter() - t0}

def judge(case, first, second):
    prompt = (f"Task:\n{case['task']}\n\nRubric:\n{case['rubric']}\n\n"
              f"Answer 1:\n{first}\n\nAnswer 2:\n{second}\n\n"
              'Reply with JSON only: {"winner": 1 or 2 or 0 for tie, "reason": "..."}')
    r = client.chat.completions.create(model=JUDGE, temperature=0, max_tokens=2000,
                                       response_format={"type": "json_object"},
                                       messages=[{"role": "user", "content": prompt}])
    return int(json.loads(r.choices[0].message.content or "{}").get("winner", 0))

def compare(case):
    a, b = run(A, case), run(B, case)
    if case.get("check"):                       # deterministic first
        return {"a_ok": case["check"](a["text"]), "b_ok": case["check"](b["text"]), "a": a, "b": b}
    w1 = judge(case, a["text"], b["text"])      # A shown first
    w2 = judge(case, b["text"], a["text"])      # B shown first
    winner = "A" if (w1, w2) == (1, 2) else "B" if (w1, w2) == (2, 1) else "tie"
    return {"winner": winner, "a": a, "b": b}
```

La regola dell’inversione fa sì che un modello vinca solo quando il giudice lo preferisce in entrambe le posizioni; qualsiasi disaccordo conta come pareggio. La quota di disaccordi è di per sé utile: un tasso alto significa che il giudice o la rubrica sono troppo vaghi. Nota il `max_tokens=4000`: sui modelli di ragionamento il pensiero conta nel limite, e un tetto basso produce risposte vuote che sembrano errori. Vedi [perché i modelli di ragionamento restituiscono risposte vuote](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).

## Quanto deve essere grande una differenza per essere reale?

I punteggi di una valutazione sono campioni. Per un tasso di superamento p su n casi, l’errore standard è √(p × (1 − p) ÷ n), e un margine al 95% è circa il doppio.

| Casi | Tasso di superamento | Margine al 95% |
| --- | --- | --- |
| 50 | 80% | circa ±11 punti |
| 100 | 80% | circa ±8 punti |
| 200 | 80% | circa ±6 punti |
| 400 | 80% | circa ±4 punti |

Quindi un modello che fa 82% contro 79% su 100 casi non ha dimostrato di essere migliore. Guarda invece le **differenze caso per caso**: quali casi sono passati da superato a fallito? Dicono più dei totali, e sui casi critici un solo ribaltamento può decidere il cambio.

## Quale deve essere la regola di decisione?

Scrivila prima di eseguire la valutazione, così il risultato non può piegarla. Un modello pratico:

1.  Nessuna regressione su alcun caso etichettato come critico.
2.  Tasso di superamento complessivo non inferiore a quello del modello attuale di più del margine d’errore.
3.  Latenza p95 entro il tuo budget; vedi [TTFT e throughput](https://broadrouter.com/it/blog/llm-latency-ttft-throughput/) per come misurarla.
4.  Costo per caso riuscito più basso, o più alto solo di una cifra che hai concordato valga la qualità. Calcola la differenza mensile con il [calcolatore dei costi delle API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).
5.  Un periodo in shadow: invia una quota del traffico reale al nuovo modello, registra entrambi e confronta prima di passare definitivamente.

Lo stesso eval set è il punto di partenza se stai pensando a un modello personalizzato: [prima del fine-tuning](https://broadrouter.com/it/blog/fine-tuning-readiness/) spiega quando prompt e retrieval bastano.

## Dove si colloca BroadNet Inference

BroadNet Inference serve diverse famiglie di modelli dietro un unico endpoint compatibile con OpenAI, tra cui [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) e [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/), quindi i candidati e un giudice di una famiglia diversa possono girare con lo stesso client e la stessa chiave. Ogni risposta riporta l’uso dei token per confrontare i costi, e i nuovi account partono con $5 di credito; senza una ricarica quel credito vale solo per [Gemma 4 VL 26B](https://broadrouter.com/it/models/gemma-4-vl-26b/), quindi prevedi una piccola ricarica per confrontare i modelli più grandi. Non include un sistema di valutazione né strumenti di giudizio ospitati; il codice qui sopra lo esegui tu. Per i carichi in arabo, [scegliere un LLM per l’arabo](https://broadrouter.com/it/blog/choosing-an-llm-for-arabic/) elenca cosa testare. I prezzi fianco a fianco sono nella [pagina di confronto](https://broadrouter.com/compare/).

Strumenti gratuiti sul tema (in inglese)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Eval (valutazione degli LLM)](https://broadrouter.com/it/glossary/eval/)

Una eval (abbreviazione di evaluation, valutazione) è un test ripetibile di un modello linguistico o di un prompt: un insieme fisso di input, una descrizione di come deve essere un buon output e un valutatore (codice, una persona o un altro modello) che assegna un punteggio a ogni output, così da poter confrontare le versioni.

[LLM-as-a-judge (LLM come giudice)](https://broadrouter.com/it/glossary/llm-as-judge/)

LLM-as-a-judge è un metodo di valutazione in cui un modello linguistico giudica gli output di altri modelli, dando un punteggio a una singola risposta secondo una rubrica oppure scegliendo la migliore tra due. Approssima il giudizio umano a un costo molto più basso, ma ha bias noti, come preferire la prima risposta o quella più lunga.

[Base URL (URL di base)](https://broadrouter.com/it/glossary/base-url/)

La base URL è l’indirizzo radice fisso di un’API, come https://api.example.com/v1, che un client antepone a ogni percorso di endpoint, come /chat/completions. Negli SDK compatibili con OpenAI, cambiare la base URL, insieme alla chiave API e all’ID del modello, punta lo stesso codice verso un altro provider.

[Credito prepagato (prepaid credit)](https://broadrouter.com/it/glossary/prepaid-credit/)

Il credito prepagato è denaro aggiunto a un account API prima dell’uso. Ogni richiesta scala il proprio costo dal saldo e, quando il saldo si esaurisce, le richieste a consumo si fermano finché non ricarichi. Limita la spesa a quanto hai versato.

[Throughput](https://broadrouter.com/it/glossary/throughput/)

Il throughput, nel serving di LLM, è la quantità totale di lavoro che un sistema completa per unità di tempo su tutte le richieste concorrenti, di solito misurata in token di output al secondo o richieste al secondo. È diverso dalla velocità per stream, cioè quanto rapidamente una singola richiesta riceve i suoi token.

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[API compatibile con OpenAI](https://broadrouter.com/it/glossary/openai-compatible-api/)

Un’API compatibile con OpenAI è un’API HTTP che accetta gli stessi formati di richiesta e di risposta dell’API di OpenAI, come POST /v1/chat/completions, così SDK e strumenti di OpenAI possono usarla cambiando solo base URL, chiave API e nome del modello.

## Domande frequenti

### Quanti esempi servono in un eval set per LLM?

Cinquanta bastano per cogliere le regressioni grandi, 200 per vedere differenze di circa 5–10 punti. La copertura conta più della dimensione, quindi includi ogni tipo di task e i casi di errore che già conosci.

### L’LLM-as-a-judge è affidabile?

In parte. Nello studio MT-Bench, i giudici forti concordavano con le preferenze umane oltre l’80% delle volte, più o meno quanto gli esseri umani concordano tra loro. Mostravano però anche bias di posizione, di verbosità e di autovalorizzazione, quindi correggili e controllali a campione.

### Il modello giudice può essere lo stesso modello che sto testando?

No. I giudici tendono a favorire le risposte che somigliano alle proprie. Usa un giudice di un’altra famiglia di modelli e tienilo fisso su una sola versione per tutto il confronto.

### Cos’è il bias di posizione nella valutazione degli LLM?

Il giudice preferisce la risposta che compare per prima, o per seconda, a prescindere dalla qualità. Si corregge giudicando ogni coppia due volte con l’ordine invertito e contando una vittoria solo quando i due ordini concordano.

### Devo confrontare costo e latenza nella stessa valutazione?

Sì. Registra token e tempi di ogni chiamata della valutazione. Un modello che prende due punti in più ma costa tre volte tanto, o è tre volte più lento, potrebbe comunque essere il cambio sbagliato.

## Continua a leggere

-   [Come scegliere un provider di API LLM: checklist in 20 punti](https://broadrouter.com/it/blog/choose-llm-api-provider-checklist/)
-   [Passare a un’API compatibile con OpenAI: la checklist di migrazione](https://broadrouter.com/it/blog/openai-compatible-api-migration-checklist/)
-   [Scegliere un’API LLM per l’arabo: cosa testare](https://broadrouter.com/it/blog/choosing-an-llm-for-arabic/)
-   [Log di utilizzo delle API LLM: costo per utente e funzione, senza PII](https://broadrouter.com/it/blog/llm-api-usage-logging/)
-   [Latenza degli LLM: TTFT, token al secondo e tempo end-to-end](https://broadrouter.com/it/blog/llm-latency-ttft-throughput/)
-   [Prima del fine-tuning: definisci il problema da risolvere](https://broadrouter.com/it/blog/fine-tuning-readiness/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-evaluate-llm-before-switching&utm_content=page-cta) ·

**Fonti**

-   [Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, arXiv 2306.05685 (consultato il 2026-11-14)](https://arxiv.org/abs/2306.05685)
-   [Documentazione di Arize, buone pratiche per gli evaluator (consultata il 2026-11-14)](https://arize.com/docs/ax/concepts/evaluators/evaluator-best-practices)
-   [Riferimento API di BroadNet Inference (consultato il 2026-11-14) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-evaluate-llm-before-switching&utm_content=sources)
-   [Prezzi di BroadNet Inference in formato leggibile dalle macchine, pricing.json (consultati il 2026-11-14) (in inglese)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-evaluate-llm-before-switching&utm_content=sources)
