Confronto con il modello base
In questa pagina
Aggiornamento 2 novembre 2026 — Disponibilità del fine-tuning. Il fine-tuning self-service di OpenAI sta venendo gradualmente eliminato: dal 7 maggio 2026, le organizzazioni che non lo hanno mai utilizzato non possono più creare job; dal 2 luglio, devi aver usato un modello fine-tuned 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 pensionamento 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é il confronto sistematico è fondamentale
Il fine-tuning ha un costo: tempo di preparazione dei dati, spese di addestramento e complessità di manutenzione. Devi dimostrare che il tuo modello fine-tuned offre un miglioramento misurabile rispetto al modello base utilizzato con un prompt ottimizzato. Se la differenza è marginale, il fine-tuning potrebbe non valere lo sforzo.
La tentazione in questo esercizio è confrontare il tuo modello addestrato con un modello base istruito male. Questo crea una dimostrazione lusinghiera ma inutile: hai battuto un avversario che hai indebolito tu stesso. L’unico confronto onesto mette il tuo modello fine-tuned contro il miglior utilizzo possibile del modello base.
Definire la baseline
La baseline è il modello base con il tuo miglior system prompt. Ottimizza questo prompt prima di confrontare. Concretamente, significa mettere per iscritto le regole che hai insegnato implicitamente tramite esempi durante il fine-tuning: il ruolo, il tono, la lunghezza attesa e come chiudere uno scambio. Il prompt qui sotto fa esattamente questo per un assistente di supporto; nota che il modello fine-tuned non ha bisogno di tali istruzioni, poiché queste regole fanno ora parte dei suoi pesi.
from openai import OpenAI
client = OpenAI()
OPTIMIZED_SYSTEM_PROMPT = """You are a customer support assistant for TechCorp.
Rules:
- Respond professionally and empathetically
- Always propose a concrete solution
- Limit responses to 3 sentences maximum
- End with a follow-up question"""
def baseline_response(question: str) -> str:
"""Gets a response from the base model."""
response = client.responses.create(
model="gpt-5.6-luna",
instructions=OPTIMIZED_SYSTEM_PROMPT,
input=question
)
return response.output_text
def fine_tune_response(question: str, model_ft: str) -> str:
"""Gets a response from the fine-tuned model."""
response = client.responses.create(
model=model_ft,
input=question
)
return response.output_text
Generare risposte affiancate
Il passo successivo è interrogare entrambi i modelli con esattamente le stesse domande e conservare le risposte accoppiate. Scegli domande rappresentative del tuo traffico reale piuttosto che casi da manuale: un reclamo per una consegna, una richiesta di procedura, un’insoddisfazione, una richiesta di rimborso, una domanda fattuale. Queste cinque famiglie fanno la differenza in produzione, non la formulazione perfetta.
import json
def compare_models(
questions: list[str],
base_model: str,
ft_model: str,
system_prompt: str
) -> list[dict]:
"""Compares responses from two models on the same questions."""
comparisons = []
for q in questions:
# Base model with optimized prompt
r_base = client.responses.create(
model=base_model,
instructions=system_prompt,
input=q
)
# Fine-tuned model (minimal or no prompt)
r_ft = client.responses.create(
model=ft_model,
input=q
)
comparisons.append({
"question": q,
"baseline_response": r_base.output_text,
"ft_response": r_ft.output_text
})
return comparisons
# Test questions
test_questions = [
"My package hasn't arrived.",
"How do I reset my password?",
"Your product isn't working as expected.",
"I would like a refund.",
"What are your opening hours?",
]
results = compare_models(
test_questions,
"gpt-5.6-luna",
"ft:gpt-5.6-luna:org::suffix:xxxxxxxx",
OPTIMIZED_SYSTEM_PROMPT
)
Far giudicare un modello terzo
Leggere a mano centinaia di coppie diventa rapidamente scoraggiante e il giudizio vacilla con l’affaticamento. Un modello terzo, che non ha prodotto nessuna delle due risposte, arbitra ogni coppia su quattro criteri ed emette un verdetto globale. Innanzitutto, neutralizza le etichette: il giudice vede “Risposta A” e “Risposta B”, mai quale modello le ha prodotte, altrimenti il suo verdetto peserà il nome del modello tanto quanto il testo. Successivamente, gestisci i casi in cui l’output non è analizzabile; altrimenti, una singola risposta malformata blocca l’intera campagna.
def judge_comparison(comparison: dict) -> dict:
"""Has a third-party model judge the comparison."""
prompt = f"""Compare these two responses to the same question.
Question: {comparison['question']}
Response A: {comparison['baseline_response']}
Response B: {comparison['ft_response']}
For each criterion, indicate which response is better (A, B, or tie):
1. Relevance of the response
2. Professionalism of tone
3. Adherence to expected format
4. Usefulness to the user
Respond in JSON: {{"relevance": "A/B/tie", "tone": "A/B/tie", "format": "A/B/tie", "usefulness": "A/B/tie", "overall_winner": "A/B/tie"}}"""
response = client.responses.create(
model="gpt-5.6-sol",
input=prompt
)
try:
return json.loads(response.output_text)
except json.JSONDecodeError:
return {"error": "Response not parseable"}
# Judge all comparisons
judgments = [judge_comparison(c) for c in results]
Ora aggrega questi verdetti in un’unica cifra. Il tasso di miglioramento — la quota di coppie in cui vince il modello fine-tuned — va letto rispetto a soglie predefinite: sopra il 60%, il guadagno è chiaro; tra il 40% e il 60%, valuta il guadagno rispetto al costo extra; al di sotto, il tuo fine-tuning non ha dimostrato il suo valore e il problema risiede quasi sempre nei dati.
def comparison_score(judgments: list[dict]) -> dict:
"""Calculates the overall comparison score."""
scores = {"A_wins": 0, "B_wins": 0, "tie": 0}
for j in judgments:
winner = j.get("overall_winner", "tie")
if winner == "A":
scores["A_wins"] += 1
elif winner == "B":
scores["B_wins"] += 1
else:
scores["tie"] += 1
total = len(judgments)
print(f"Base model wins: {scores['A_wins']}/{total}")
print(f"Fine-tuned model wins: {scores['B_wins']}/{total}")
print(f"Tie: {scores['tie']}/{total}")
improvement_rate = scores["B_wins"] / total * 100
print(f"\nImprovement rate: {improvement_rate:.1f}%")
if improvement_rate >= 60:
print("Fine-tuning provides a significant improvement.")
elif improvement_rate >= 40:
print("Modest improvement—check if the cost is justified.")
else:
print("Fine-tuning does not provide a clear improvement.")
return scores
comparison_score(judgments)
Confrontare i costi
La qualità è solo metà della decisione. Il fine-tuning spesso riduce i token in input poiché il lungo prompt diventa inutile, ma ogni token fatturato su un modello fine-tuned costa di più. Questi due effetti tirano in direzioni opposte e solo il calcolo decide. La funzione qui sotto li mette a confronto su un mese di traffico: un prompt che scende da 500 a 50 token compensa ampiamente un tasso di input raddoppiato, ma questo non varrebbe con un prompt base già breve.
def compare_costs(
requests_per_day: int,
base_prompt_tokens: int,
ft_prompt_tokens: int,
avg_output_tokens: int,
base_input_price: float,
ft_input_price: float,
output_price: float
):
"""Compares monthly costs between base and fine-tuned models."""
days = 30
base_cost = days * requests_per_day * (
base_prompt_tokens * base_input_price / 1_000_000 +
avg_output_tokens * output_price / 1_000_000
)
ft_cost = days * requests_per_day * (
ft_prompt_tokens * ft_input_price / 1_000_000 +
avg_output_tokens * output_price / 1_000_000
)
savings = base_cost - ft_cost
print(f"Monthly base cost: ${base_cost:.2f}")
print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
print(f"Monthly savings: ${savings:.2f}")
# Example
compare_costs(
requests_per_day=1000,
base_prompt_tokens=500, # long prompt with instructions
ft_prompt_tokens=50, # short prompt, behavior is integrated
avg_output_tokens=200,
base_input_price=0.15,
ft_input_price=0.30, # fine-tuned costs more per token
output_price=0.60
)
Confrontare la latenza
Accorciare un prompt di diverse centinaia di token influisce anche sul tempo di risposta, un criterio che i tuoi utenti notano ben prima delle sfumature di tono. Misura la latenza sulle stesse domande usate per il confronto qualitativo, fuori dagli orari di punta, e ripeti la misurazione più volte: un singolo valore riflette per lo più lo stato della rete al momento del test.
import time
def measure_latency(model: str, questions: list[str], prompt: str = "") -> float:
"""Measures the average latency of a model."""
latencies = []
for q in questions:
start = time.time()
kwargs = {"model": model, "input": q}
if prompt:
kwargs["instructions"] = prompt
client.responses.create(**kwargs)
latencies.append(time.time() - start)
avg = sum(latencies) / len(latencies)
print(f"{model} — Average latency: {avg:.2f}s")
return avg
Decidere in base ai risultati
Ora incrocia qualità e costi. Ogni combinazione richiede una decisione diversa, e la più scomoda rimane la via di mezzo: quando i due modelli sono pari, devi abbandonare un lavoro già pagato piuttosto che cercare giustificazioni a posteriori.
| Risultato | Azione |
|---|---|
| FT vince su qualità + costi | Distribuisci il modello fine-tuned |
| FT vince su qualità, perde sui costi | Valuta se la qualità giustifica il costo extra |
| Risultati simili | Resta sul modello base + prompt |
| Vince il base | Migliora i tuoi dati e riprova |
Punti chiave
- Confronta sempre con un modello base + prompt ottimizzato, non con un prompt basilare
- Usa il giudizio di un LLM per automatizzare il confronto qualitativo
- Misura costi e latenza, non solo la qualità
- Un tasso di miglioramento superiore al 60% giustifica il fine-tuning
- Se il fine-tuning non offre un miglioramento chiaro, resta sul prompt engineering