Monitoraggio dell'addestramento
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 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