Valuta il tuo modello fine-tunato
In questa pagina
Aggiornamento 2 novembre 2026 — Disponibilità del fine-tuning. Il servizio di fine-tuning self-service di OpenAI sta venendo dismesso: dal 7 maggio 2026, le organizzazioni che non lo hanno mai utilizzato non possono più creare job; dal 2 luglio, devi aver utilizzato un modello fine-tunato negli ultimi 60 giorni; e a partire dal 6 gennaio 2027, nessun cliente potrà avviare nuovi job. I modelli già addestrati rimangono utilizzabili fino al ritiro del loro modello base. Questo corso rimane utile per comprendere e sfruttare un modello esistente; per nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.
Perché la valutazione è essenziale
Un fine-tuning di successo non si misura solo dalla loss. La vera domanda è: il tuo modello fine-tunato è effettivamente migliore del modello base per il tuo caso d’uso? Una curva in netta discesa prova solo che il modello ha imparato a riprodurre i tuoi esempi; non dice nulla sul suo comportamento rispetto a richieste mai viste. Questa lezione ti mostra come costruire un protocollo di valutazione rigoroso, combinando metriche automatizzate, giudizio tramite LLM e revisione umana.
Costruire un set di test
Il tuo set di test deve essere separato sia dai dati di training che da quelli di validazione. La distinzione conta: il set di validazione monitora l’addestramento e influenza quindi le tue decisioni sugli iperparametri, contaminandolo gradualmente. Il set di test, al contrario, viene aperto solo quando il modello è congelato. Rappresenta le situazioni del mondo reale che il modello incontrerà in produzione, con le stesse proporzioni di casi semplici e complessi. Una suddivisione 80/10/10 su un corpus precedentemente mescolato è un punto di partenza ragionevole.
import json
import random
def prepare_datasets(file: str, ratios: tuple = (0.8, 0.1, 0.1)):
"""Splits data into train/validation/test."""
with open(file, "r") as f:
examples = [json.loads(l) for l in f]
random.shuffle(examples)
n = len(examples)
i1 = int(n * ratios[0])
i2 = int(n * (ratios[0] + ratios[1]))
datasets = {
"train": examples[:i1],
"validation": examples[i1:i2],
"test": examples[i2:]
}
for name, data in datasets.items():
with open(f"{name}.jsonl", "w") as f:
for ex in data:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print(f"{name}: {len(data)} examples")
return datasets
prepare_datasets("all_data.jsonl")
Valutazione automatizzata
Valutazione basata su metriche
Il principio è semplice: per ogni esempio di test, rimuovi il messaggio dell’assistente — quella è la risposta attesa, che il modello non deve vedere — invia il resto e mantieni input, risposta di riferimento e risposta generata fianco a fianco. Questa struttura a tre colonne è la base per tutto ciò che segue; usarla per il calcolo delle metriche o per il giudizio qualitativo è solo una questione di elaborazione successiva.
from openai import OpenAI
client = OpenAI()
def evaluate_model(model: str, test_examples: list[dict]) -> dict:
"""Evaluates a model on a test set."""
results = []
for ex in test_examples:
# Extract the question (without the expected answer)
input_messages = [
m for m in ex["messages"] if m["role"] != "assistant"
]
expected_answer = next(
m["content"] for m in ex["messages"] if m["role"] == "assistant"
)
# Get the model's response
response = client.responses.create(
model=model,
input=input_messages
)
model_answer = response.output_text
results.append({
"input": input_messages[-1]["content"],
"expected": expected_answer,
"obtained": model_answer
})
return results
Valutazione con LLM come giudice
Una tecnica potente consiste nell’utilizzare un modello ad alte prestazioni per giudicare la qualità della risposta. Il confronto parola per parola con il riferimento diventa inutilizzabile non appena sono accettabili più formulazioni; un giudice, invece, apprezza la sostanza. La qualità del suo verdetto dipende interamente dalla precisione del prompt: quattro criteri valutati da 1 a 5, un output JSON forzato e un commento in testo libero che userai in seguito per comprendere i fallimenti. Prevedi i casi in cui l’output non è analizzabile invece di lasciare che un’eccezione interrompa la campagna.
def evaluate_with_judge(results: list[dict]) -> list[dict]:
"""Uses gpt-5.6-sol as a judge to evaluate responses."""
evaluations = []
for r in results:
judge_prompt = f"""Evaluate the quality of the obtained response compared to the expected response.
Question: {r['input']}
Expected response: {r['expected']}
Obtained response: {r['obtained']}
Criteria (rate each from 1 to 5):
1. Accuracy: Is the information correct?
2. Completeness: Are all important points covered?
3. Style: Is the tone and format appropriate?
4. Conciseness: Is the response an appropriate length?
Respond in JSON: {{"accuracy": N, "completeness": N, "style": N, "conciseness": N, "comment": "..."}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=judge_prompt
)
try:
evaluation = json.loads(response.output_text)
evaluations.append(evaluation)
except json.JSONDecodeError:
evaluations.append({"error": "Response not parseable"})
return evaluations
Metriche specializzate
I due approcci precedenti funzionano bene per le risposte scritte. Non appena l’output del tuo modello ha una struttura fissa, diventano possibili misure più dirette che ti risparmiano la deviazione attraverso un giudice.
Per la classificazione
Quando l’output atteso appartiene a un insieme chiuso — una categoria di ticket, un sentiment, un codice prodotto — la corrispondenza esatta torna rilevante. Normalizza maiuscole/minuscole e spazi prima di confrontare; altrimenti, “Urgente” contro “urgente” conterà come errore e distorcerà il tuo tasso.
def classification_metrics(results: list[dict]) -> dict:
"""Calculates precision, recall, and F1 for a classification task."""
correct = sum(
1 for r in results
if r["expected"].strip().lower() == r["obtained"].strip().lower()
)
total = len(results)
precision = correct / total if total > 0 else 0
print(f"Precision: {precision:.2%} ({correct}/{total})")
return {"precision": precision, "correct": correct, "total": total}
Per il Function Calling
Il function calling si giudica su due assi che devono essere misurati separatamente. Un modello che sceglie la funzione giusta ma sbaglia il parametro fallisce in modo diverso da uno che chiama lo strumento completamente sbagliato: il primo problema si risolve con esempi di estrazione, il secondo con esempi di discriminazione. Un singolo punteggio globale maschererebbe questa distinzione e ti lascerebbe lavorare alla cieca.
def function_calling_metrics(results: list[dict]) -> dict:
"""Evaluates the quality of function calls."""
stats = {"correct_function": 0, "correct_params": 0, "total": 0}
for r in results:
stats["total"] += 1
if r.get("expected_function") == r.get("obtained_function"):
stats["correct_function"] += 1
if r.get("expected_params") == r.get("obtained_params"):
stats["correct_params"] += 1
print(f"Correct function: {stats['correct_function']}/{stats['total']}")
print(f"Correct parameters: {stats['correct_params']}/{stats['total']}")
return stats
Valutazione umana
La valutazione automatizzata non cattura tutto. Un tono leggermente condiscendente, una frase che non piace ai tuoi clienti, una risposta tecnicamente corretta ma inutilizzabile: questi difetti emergono solo sotto l’occhio umano. Il protocollo è semplice. Campiona da venti a cinquanta risposte a caso, mai i casi che hai già segnalato come problematici, altrimenti misurerai solo il tuo bias di selezione. Definisci poi criteri chiari e misurabili e formalizzali in una griglia di valutazione standardizzata, così due revisori giudicano la stessa cosa.
Infine, fai valutare da più persone e calcola l’accordo inter-giudice. Un forte disaccordo non segnala necessariamente un modello scadente: molto spesso rivela che la tua griglia rimane ambigua e ha bisogno di chiarimenti prima di poter trarre qualsiasi conclusione.
Esempio di griglia di valutazione
| Criterion | 1 (Poor) | 3 (Acceptable) | 5 (Excellent) |
|---|---|---|---|
| Relevance | Off-topic | Partially relevant | Perfectly targeted |
| Tone | Inappropriate | Acceptable but plain | Perfectly aligned |
| Format | Not followed | Partially followed | Perfectly followed |
Rapporto di valutazione
Un ultimo riflesso separa una valutazione da una decisione: registra entrambe le famiglie di risultati in un unico rapporto, accompagnato da una raccomandazione esplicita. La soglia che imposti — qui una media umana di 4 per andare in produzione, 3 per iterare sui dati — deve essere scelta prima di lanciare la campagna. Decisa dopo, si adatta sempre al risultato che speravi di ottenere.
def evaluation_report(auto_results: dict, human_results: dict):
"""Generates a combined evaluation report."""
print("=" * 60)
print("FINE-TUNED MODEL EVALUATION REPORT")
print("=" * 60)
print(f"\nAutomated metrics:")
for k, v in auto_results.items():
print(f" {k}: {v}")
print(f"\nHuman evaluation:")
for k, v in human_results.items():
print(f" {k}: {v}")
print(f"\nRecommendation:")
average_score = sum(human_results.values()) / len(human_results)
if average_score >= 4:
print(" Model is ready for production")
elif average_score >= 3:
print(" Improvements needed—iterate on data")
else:
print(" Insufficient results—rethink your approach")
Punti chiave
- Separa sempre un set di test indipendente (né training né validazione)
- Combina valutazione automatizzata e umana
- La valutazione con LLM come giudice è un buon compromesso tra le due
- Definisci criteri misurabili prima di iniziare
- Un punteggio di loss basso non garantisce la qualità per la produzione