Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Confronto con il modello base

Lezione 11 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Perché il confronto sistematico è fondamentale
  2. Definire la baseline
  3. Generare risposte affiancate
  4. Far giudicare un modello terzo
  5. Confrontare i costi
  6. Confrontare la latenza
  7. Decidere in base ai risultati
  8. Punti chiave

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.

RisultatoAzione
FT vince su qualità + costiDistribuisci il modello fine-tuned
FT vince su qualità, perde sui costiValuta se la qualità giustifica il costo extra
Risultati similiResta sul modello base + prompt
Vince il baseMigliora 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