Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Monitoraggio dell'addestramento

Lezione 7 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Perché monitorare l’addestramento
  2. Le due metriche da leggere
  3. Tracciare gli eventi via API
  4. Checkpoint e risultati intermedi
  5. Sapere quando fermarsi
  6. Un report di sintesi per ogni esecuzione
  7. 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 lo hanno mai utilizzato non possono più creare job; dal 2 luglio, devi aver usato 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 resta utile per comprendere e sfruttare un modello esistente; per nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.

Perché monitorare l’addestramento

Avviare un job di fine-tuning e dimenticarsene ti lascia con un fatto compiuto: un’ora dopo, scopri un modello senza sapere cosa sia successo nel frattempo. Osservando le metriche mentre l’addestramento è in corso, individui i problemi presto, decidi di aggiustare gli iperparametri prima di bruciare tutto il budget e, soprattutto, capisci perché una esecuzione ha performato meglio di un’altra. Il monitoraggio trasforma una serie di tentativi in una disciplina ingegneristica.

Le due metriche da leggere

La perdita di addestramento (training loss) misura quanto il modello sbaglia sui dati di training, ovvero proprio i dati che sta ingerendo in quel momento. Dovrebbe diminuire nel corso degli step: è il segnale che l’apprendimento sta avvenendo. Una perdita che si blocca o risale indica un problema, solitamente un learning rate mal calibrato o un corpus troppo eterogeneo.

La perdita di validazione (validation loss) misura le prestazioni su dati che il modello non ha mai visto durante l’addestramento, il file che hai messo da parte durante la divisione. Questa è la metrica più affidabile per valutare la qualità reale del tuo modello, perché è l’unica che il modello non può migliorare memorizzando. È la loro evoluzione congiunta a fornire la diagnosi.

Perdita di addestramento Perdita di validazione Diagnosi
In diminuzione In diminuzione Tutto ok, continua
In diminuzione In aumento Overfitting — riduci le epoche
Stazionaria Stazionaria Underfitting — aumenta il learning rate
Oscillante Oscillante Instabilità — riduci il learning rate

La seconda riga è quella che costa di più in produzione: una perdita di addestramento che continua a scendere mentre quella di validazione risale descrive un modello che sta memorizzando i tuoi esempi a memoria. Sulla carta, tutto sembra migliorare; nella realtà, ogni step aggiuntivo degrada la sua capacità di rispondere a una domanda che non ha mai visto.

Tracciare gli eventi via API

L’API non invia notifiche push: devi interrogare il job a intervalli regolari. Il ciclo sottostante recupera i nuovi eventi, li visualizza in ordine cronologico evitando di mostrare nuovamente quelli già visti e restituisce il controllo non appena il job raggiunge uno stato terminale.

from openai import OpenAI
import time

client = OpenAI()

def monitor_job(job_id: str):
    """Monitora un job in tempo reale."""
    last_event = None

    while True:
        job = client.fine_tuning.jobs.retrieve(job_id)

        # Recupera i nuovi eventi
        events = client.fine_tuning.jobs.list_events(
            fine_tuning_job_id=job_id,
            limit=50
        )

        for event in reversed(events.data):
            if last_event and event.id == last_event:
                continue
            print(f"[{event.created_at}] {event.message}")

        if events.data:
            last_event = events.data[0].id

        if job.status in ("succeeded", "failed", "cancelled"):
            print(f"\nJob terminato: {job.status}")
            if job.status == "succeeded":
                print(f"Modello: {job.fine_tuned_model}")
            return job

        time.sleep(30)

# Utilizzo
job = monitor_job("ftjob-xxxxxxxxxxxxxxxx")

Gli eventi non contengono solo messaggi di testo: trasportano anche i valori di perdita a ogni step. Estrarli ti permette di tracciare una curva invece di leggere righe di log, ed è su una curva che individui a colpo d’occhio un picco nella perdita di validazione.

def extract_metrics(job_id: str) -> dict:
    """Estrae le metriche di perdita da un job completato."""
    events = client.fine_tuning.jobs.list_events(
        fine_tuning_job_id=job_id,
        limit=200
    )

    training_losses = []
    validation_losses = []

    for event in events.data:
        data = event.data
        if data and "train_loss" in str(data):
            training_losses.append(data)
        if data and "valid_loss" in str(data):
            validation_losses.append(data)

    return {
        "training": training_losses,
        "validation": validation_losses
    }

Checkpoint e risultati intermedi

OpenAI salva i checkpoint durante l’addestramento. Se il job fallisce o lo annulli, a volte puoi recuperare un checkpoint intermedio utilizzabile: in altre parole, un’esecuzione interrotta non è necessariamente un’esecuzione persa. Questa è anche una risorsa preziosa in caso di overfitting tardivo: il checkpoint preso prima del picco di perdita di validazione potrebbe essere migliore del modello finale.

# Elenca i checkpoint per un job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
    fine_tuning_job_id=job.id
)

for cp in checkpoints.data:
    print(f"Step {cp.step_number}")
    print(f"  Modello: {cp.fine_tuned_model_checkpoint}")
    if cp.metrics:
        print(f"  Perdita di addestramento: {cp.metrics.train_loss:.4f}")
        if hasattr(cp.metrics, "valid_loss"):
            print(f"  Perdita di validazione: {cp.metrics.valid_loss:.4f}")

Sapere quando fermarsi

Tre segnali giustificano l’interruzione di un addestramento in corso. Il primo è una perdita di validazione che sale da diversi step, non solo uno: un valore isolato è rumore, una tendenza su cinque punti è overfitting. Il secondo è una perdita di addestramento vicina allo zero, il che significa che il modello sta riproducendo i tuoi esempi alla lettera e non ha più nulla da imparare da essi. Il terzo è più prosaico: i tuoi test non migliorano da un checkpoint all’altro e ogni step aggiuntivo aumenta solo la fattura.

# Se rilevi un problema, annulla il job
client.fine_tuning.jobs.cancel(job.id)
print("Job annullato. Regola i tuoi dati o iperparametri e riavvia.")

Un report di sintesi per ogni esecuzione

Concludi ogni sessione di addestramento producendo un registro azionabile. La funzione seguente raccoglie in un unico output l’ID del job, il modello base, le epoche utilizzate, il numero di token addestrati e le metriche dall’ultimo checkpoint. Incolla questi report nel tuo registro delle esecuzioni: tra un mese, ti diranno perché hai mantenuto questa versione piuttosto che un’altra.

def job_report(job_id: str):
    """Genera un report di sintesi per il job."""
    job = client.fine_tuning.jobs.retrieve(job_id)

    print("=" * 50)
    print(f"Job: {job.id}")
    print(f"Modello base: {job.model}")
    print(f"Stato: {job.status}")
    print(f"Epoche: {job.hyperparameters.n_epochs}")

    if job.status == "succeeded":
        print(f"Modello fine-tunato: {job.fine_tuned_model}")
        print(f"Token addestrati: {job.trained_tokens}")

    if job.status == "failed":
        print(f"Errore: {job.error}")

    # Checkpoint
    checkpoints = client.fine_tuning.jobs.checkpoints.list(
        fine_tuning_job_id=job_id
    )
    if checkpoints.data:
        latest = checkpoints.data[0]
        print(f"Ultimo checkpoint: step {latest.step_number}")
        if latest.metrics:
            print(f"  Perdita di addestramento: {latest.metrics.train_loss:.4f}")

    print("=" * 50)

job_report("ftjob-xxxxxxxxxxxxxxxx")

Punti chiave

  • Monitora sempre la perdita di validazione: è il tuo vero indicatore di qualità
  • Se la perdita di validazione sale, sei in overfitting: riduci le epoche
  • I checkpoint ti permettono di recuperare uno stato intermedio
  • Automatizza il monitoraggio per i job di lunga durata
  • Documenta le metriche di ogni esecuzione per confrontare le tue iterazioni