BroadRouter
Inizia

Come valutare un LLM prima di cambiare provider

A cura del team di BroadNet Inference · 5 min di lettura · Pubblicato

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.

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 sono una base URL e un ID di modello. La checklist di migrazione copre quella parte, e la checklist per scegliere il provider 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 servono a fare una rosa di candidati. Un piccolo set di 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, 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 è 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:

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.

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 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.
  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 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, GLM 5.3 e 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, 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 elenca cosa testare. I prezzi fianco a fianco sono nella pagina di confronto.

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.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity