Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Iterazione: quando eseguire un nuovo fine-tuning

Lezione 13 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Il fine-tuning è un processo iterativo
  2. Analizza gli errori prima di correggerli
  3. Riconoscere quando iterare
  4. Arricchisci invece di ricominciare da zero
  5. Fine-tuning continuo e suoi limiti
  6. Il ciclo completo
  7. Documenta ogni iterazione
  8. Punti chiave

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 hanno mai eseguito un job di fine-tuning non possono più crearne uno; dal 2 luglio, devi aver utilizzato un modello con fine-tuning 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 i nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.

Il fine-tuning è un processo iterativo

La tua prima esecuzione di fine-tuning sarà raramente perfetta. Il miglioramento deriva da cicli iterativi: analizza gli errori, arricchisci i tuoi dati, riaddestra e rivaluta. Questa lezione ti insegna come identificare quando e come iterare in modo efficace e, altrettanto importante, come riconoscere le situazioni in cui un nuovo addestramento sarebbe inutile.

Analizza gli errori prima di correggerli

Il riflesso naturale dopo una valutazione deludente è aggiungere esempi a caso, sperando che il volume risolva il problema. È il modo più veloce per bruciare il tuo budget di addestramento senza fare progressi. Inizia classificando ogni fallimento in una categoria: formattazione errata, tono inappropriato, errore fattuale, risposta incompleta, risposta fuori tema o pura allucinazione. La distribuzione risultante ti indica dove concentrare gli sforzi e spesso rivela una sorpresa: quello che pensavi fosse un problema di stile si rivela un problema di completezza.

def analyze_errors(results: list[dict]) -> dict:
    """Categorizes errors from the fine-tuned model."""
    categories = {
        "format": [],       # Incorrect response format
        "tone": [],         # Inappropriate tone
        "factual": [],      # Incorrect information
        "incomplete": [],   # Response too short or missing elements
        "off_topic": [],    # Does not answer the question
        "hallucination": [] # Invents information
    }

    for r in results:
        if r.get("score", 5) < 3:
            # Classify the error (can be done manually or by an LLM)
            category = classify_error(r)
            categories[category].append(r)

    print("Error distribution:")
    for cat, errors in categories.items():
        if errors:
            print(f"  {cat}: {len(errors)} cases")

    return categories

Successivamente, esamina i casi all’interno della stessa categoria per trovare un denominatore comune. Poniti sempre le stesse domande: il modello fallisce su un tipo specifico di domanda? Gli errori si concentrano su certi argomenti? Il problema deriva dai dati o dagli iperparametri? Fallimenti sparsi su tutti gli argomenti ma sempre della stessa natura indicano una mancanza di esempi; fallimenti concentrati in un dominio specifico segnalano un vuoto di copertura; risposte che si attengono troppo strettamente agli esempi di addestramento indipendentemente dalla domanda indicano un overfitting che richiede una correzione sul numero di epoche.

Riconoscere quando iterare

Alcuni segnali richiedono inequivocabilmente una nuova versione e ognuno necessita di una risposta diversa. Un modello che allucina su un argomento non si corregge mostrandogli più risposte corrette su quell’argomento, ma insegnandogli a rifiutare gentilmente quando non sa.

SegnaleAzione
Errori di formattazione ricorrentiAggiungi più esempi con il formato corretto
Il modello allucina su certi argomentiAggiungi esempi in cui rifiuta gentilmente
Overfitting rilevatoRiduci le epoche, diversifica i dati
Nuovi casi d’uso da coprireAggiungi esempi per questi casi
Feedback negativo mirato dagli utentiTrasforma il feedback in esempi corretti

Al contrario, diverse situazioni dovrebbero dissuaderti dal riaddestrare. Quando gli errori sono rari e non sistematici, un aggiustamento del prompt li gestisce in modo più rapido ed economico. Quando le lamentele riguardano la latenza o i tempi di attesa, il problema risiede nella tua infrastruttura e nessun amount di addestramento lo risolverà. Quando hai raccolto solo una manciata di nuovi esempi dall’ultima versione, il guadagno atteso non coprirà il costo dell’esecuzione. E quando diventa disponibile un nuovo modello base, testalo così com’è prima: a volte ottiene da solo, senza addestramento, ciò che la tua versione precedente faticava a fornire.

Arricchisci invece di ricominciare da zero

L’iterazione incrementale significa aggiungere esempi mirati a un dataset esistente senza toccare il resto. Questa è l’operazione più frequente e semplice: carichi il file corrente, concatenui i nuovi casi e riscrivi tutto in formato JSONL. Il conteggio finale funge da controllo: un totale che non corrisponde alla somma attesa indica un errore di lettura del file o righe perse.

import json

def enrich_dataset(
    existing_dataset: str,
    new_examples: list[dict],
    output: str
):
    """Adds new examples to the existing dataset."""
    # Load existing data
    with open(existing_dataset, "r") as f:
        existing = [json.loads(l) for l in f]

    # Merge
    combined = existing + new_examples

    # Save
    with open(output, "w") as f:
        for ex in combined:
            f.write(json.dumps(ex, ensure_ascii=False) + "\n")

    print(f"Enriched dataset: {len(existing)} + {len(new_examples)} = {len(combined)}")

L’iterazione correttiva è ancora più preziosa perché trasforma i tuoi fallimenti in materia prima. Ogni errore individuato in produzione fornisce una domanda reale; devi solo scrivere la risposta che avresti voluto vedere e la coppia diventa un esempio di addestramento. Nota che la risposta sbagliata non va nell’esempio finale: aiuta a documentare il caso e a decidere se la correzione vale lo sforzo, ma il modello impara solo dalla versione corretta.

def error_to_example(
    question: str,
    bad_response: str,
    good_response: str,
    system_msg: str
) -> dict:
    """Transforms an error into a training example."""
    return {
        "messages": [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": question},
            {"role": "assistant", "content": good_response}
        ]
    }

# Transform a batch of errors
corrections = []
for error in detected_errors:
    correction = error_to_example(
        question=error["question"],
        bad_response=error["model_response"],
        good_response=error["corrected_response"],
        system_msg=SYSTEM_PROMPT
    )
    corrections.append(correction)

Fine-tuning continuo e suoi limiti

Nulla ti impedisce di eseguire il fine-tuning su un modello già sottoposto a fine-tuning: basta passare il suo ID completo nel parametro model invece del nome del modello base. L’operazione è allettante poiché addestra solo sui nuovi dati.

# Fine-tune from an already fine-tuned model
job_v2 = client.fine_tuning.jobs.create(
    training_file=new_file.id,
    model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx",  # v1 model as base
    suffix="my-assistant-v2"
)

Attenzione: il fine-tuning continuo accumula bias. Dopo 2-3 iterazioni successive, è spesso meglio ricominciare da capo dal modello base con un dataset completo e arricchito. Ogni strato amplifica le peculiarità del precedente, incluse quelle non intenzionali, e il modello finisce per rispondere con una rigidità che nessuno gli ha esplicitamente insegnato.

Il ciclo completo

I passaggi seguenti formano il ciclo che ripeterai per ogni versione. Se affronti prima gli errori più frequenti, la versione successiva mostrerà guadagni misurabili sul tuo set di test; affrontarli in ordine casuale produce solo miglioramenti diffusi difficili da difendere davanti al tuo team.

1

Raccogli gli errori

Identifica i casi in cui il modello fallisce in produzione o durante la valutazione.

2

Categorizza e dai priorità

Classifica gli errori per tipo e affronta prima quelli più frequenti.

3

Crea esempi correttivi

Trasforma ogni errore in un esempio di addestramento con la risposta corretta.

4

Riaddestra e rivaluta

Addestra la nuova versione e confrontala con la precedente sullo stesso set di test.

Documenta ogni iterazione

Dopo quattro o cinque versioni, nessuno ricorda più cosa distinguesse la v2 dalla v3 o perché la v4 sia stata abbandonata. Registrare sistematicamente ogni esecuzione — la composizione del dataset, la fonte dei nuovi esempi, gli iperparametri, i risultati e la decisione presa — ti fornisce queste informazioni quando una regressione ti costringe a tornare sui tuoi passi. Presta particolare attenzione alla fonte dei nuovi esempi: solo quello ti dirà, mesi dopo, se il degrado derivava da un batch di dati scelto male.

iteration_log = {
    "version": "v3",
    "date": "2026-04-02",
    "base_model": "gpt-5.6-luna",
    "dataset": {
        "train": 350,
        "validation": 45,
        "new_examples": 50,
        "new_examples_source": "production errors week 12"
    },
    "hyperparameters": {
        "n_epochs": 3,
        "learning_rate_multiplier": "auto",
        "batch_size": "auto"
    },
    "results": {
        "validation_loss": 0.42,
        "precision_test": 0.91,
        "avg_csat": 4.3,
        "improvement_vs_v2": "+5% precision, +0.2 CSAT"
    },
    "decision": "Deployed to production on 2026-04-03"
}

Punti chiave

  • Il fine-tuning è iterativo: pianifica più cicli
  • Categorizza gli errori prima di correggerli nei dati
  • Trasforma il feedback degli utenti in esempi di addestramento
  • Dopo 2-3 iterazioni successive, ricomincia dal modello base
  • Documenta ogni iterazione per mantenere una cronologia chiara