Il fine-tuning è spesso la prima soluzione a cui si pensa quando un modello sbaglia qualcosa, e spesso è quella sbagliata. Costa raccolta dei dati, etichettatura, cicli di addestramento e un modello che poi devi mantenere. Molti errori spariscono con un prompt più chiaro, il retrieval del documento giusto o un controllo nel codice sull’output. Questo articolo serve a capire in quale caso ti trovi, e che cosa preparare se un modello su misura ti serve davvero.
Quale problema stai cercando di risolvere?
Dai un nome all’errore prima di dare un nome alla soluzione. La maggior parte degli errori degli LLM rientra in pochi schemi, e ognuno ha un primo passo più economico:
| Sintomo | Prova prima | Il fine-tuning aiuta quando |
|---|---|---|
| Fatti sbagliati o superati | Retrieval (RAG) sui tuoi documenti | Raramente; i fatti che cambiano richiedono comunque il retrieval |
| Formato sbagliato, JSON rotto | Output strutturato, controlli sullo schema, un retry | Il formato è insolito e gli esempi nel prompt non bastano |
| Etichette o categorie incoerenti | Definizioni chiare ed esempi few-shot | L’insieme di etichette è ampio o sottile e gli esempi non stanno nel prompt |
| Tono o stile sbagliato | Una guida di stile nel prompt di sistema, con esempi | Uno stile aziendale deve reggere su migliaia di output |
| Termini di settore capiti o scritti male | Un elenco di vocaboli nel prompt, correzione a posteriori nel codice | I modelli vocali sbagliano ripetutamente gli stessi nomi, codici o numeri |
| Troppo lento o troppo costoso su larga scala | Un modello più piccolo, prompt caching, prompt più corti | Un piccolo modello con fine-tuning può eguagliarne uno grande su un compito ristretto |
| Lingua o dialetto sbagliato | Istruzioni nella lingua giusta; vedi prompt engineering per l’arabo | Il modello capisce ma non scrive nel dialetto che ti serve |
La guida di OpenAI descrive lo stesso ordine: prima scrivi le valutazioni, poi itera sui prompt, e usa il fine-tuning per alcuni casi d’uso. Dice che il processo di prompt engineering “may be all you need in order to get great results.” (traduzione: «potrebbe essere tutto ciò che ti serve per ottenere ottimi risultati»). Elenca che cosa aggiunge il fine-tuning rispetto al prompting: più esempi di quanti ne stiano in un prompt, prompt più corti che fanno risparmiare token, addestramento su dati che non vuoi inviare a ogni richiesta, e rendere un modello più piccolo bravo in un compito.
Come dimostri che l’errore è ricorrente?
Con un set di valutazione. Raccogli da 100 a 200 input reali con output corretti noti, come in valutare un LLM prima di cambiarlo. Dai un punteggio al prompt attuale. Poi etichetta ogni errore con una breve categoria: wrong_label, missing_field, dialect, hallucinated_fact e così via.
Uno schema è candidato al fine-tuning solo se sono vere tutte e tre le condizioni:
- È frequente. Rappresenta una quota significativa degli errori, non uno o due casi strani.
- Resiste alle soluzioni economiche. Hai provato istruzioni più chiare, esempi, retrieval e validazione, e la categoria c’è ancora.
- È coerente. Le persone sono d’accordo sulla risposta giusta. Se due dei tuoi revisori etichettano diversamente lo stesso caso, un modello addestrato sulle loro etichette imparerà il disaccordo.
Scrivi il risultato in una breve frase, come in questo esempio inventato: «Sul nostro set di supporto in arabo da 200 casi, il prompt migliore etichetta come consegna il 18% dei ticket di fatturazione; gli esempi few-shot lo riducono al 15%». Quella frase è il brief per un fine-tune, e il numero da battere.
Quali modifiche più semplici conviene testare prima?
Eseguile in ordine di costo, e ricalcola il punteggio dopo ognuna:
- Istruzioni. Definisci ogni etichetta o campo. Di’ che cosa fare in caso di dubbio.
- Esempi. Aggiungi da tre a dieci esempi reali, compresi i casi difficili.
- Retrieval. Se le risposte richiedono fatti, recupera il passaggio pertinente. Ricerca RAG in arabo e contesto lungo vs RAG spiegano le scelte.
- Vincoli. Usa l’output strutturato dove il modello lo supporta, e controlla l’output nel codice. Richiedi una volta indicando l’errore.
- Un altro modello. Un modello di base diverso potrebbe già fare ciò che ti serve. Lo stesso set di valutazione te lo dice in un’ora.
Ogni passo costa ore, non settimane, e ognuno ti lascia un riferimento migliore che un eventuale fine-tune dovrà battere, se ti serve ancora.
Quali dati ti servono, e hai il diritto di usarli?
Prima della qualità, verifica i diritti. I dati di addestramento spesso vengono da conversazioni con i clienti, documenti o registrazioni di chiamate. Ti serve una base giuridica e, spesso, un consenso o una clausola contrattuale che copra l’addestramento. Controlla la tua informativa sulla privacy e i contratti con i clienti, e rimuovi i dati personali che non ti servono. Non dare per scontato che il tuo provider API li stia raccogliendo per te: l’informativa sulla privacy di BroadNet, per esempio, dice che non conserva il contenuto dell’inferenza e non usa i dati di inferenza per addestrare, fare fine-tuning o valutare modelli.
Poi verifica la qualità. Questo script legge un file di addestramento e un file di valutazione nel formato JSONL di chat più diffuso (un {"messages": [...]} per riga, che termina con la risposta dell’assistente) e segnala i problemi che rovinano in silenzio i fine-tune: righe rotte, duplicati, lo stesso input con risposte diverse, elementi di valutazione finiti nell’addestramento, bilanciamento delle etichette e possibili dati personali.
import json, re, sys
from collections import Counter
DIAC = re.compile(r"[ً-ٰٟـ]") # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
"phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}
def norm(s: str) -> str:
s = DIAC.sub("", s.lower())
s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
return " ".join(s.split())
def load(path):
rows, errors = [], []
for i, line in enumerate(open(path, encoding="utf-8"), 1):
try:
ex = json.loads(line)
roles = [m["role"] for m in ex["messages"]]
if roles[-1] != "assistant" or "user" not in roles:
raise ValueError(f"roles {roles}")
rows.append(ex)
except (ValueError, KeyError, IndexError, TypeError) as e:
errors.append(f"line {i}: {e}")
return rows, errors
def key(ex): # the input side, normalised: what the model sees
return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))
def check(train_path, eval_path):
train, errs = load(train_path)
evals, eval_errs = load(eval_path)
keys = Counter(key(e) for e in train)
labels = Counter(e["messages"][-1]["content"].strip() for e in train)
leaked = {key(e) for e in evals} & set(keys)
pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
conflicts = Counter()
seen = {}
for e in train:
k, a = key(e), e["messages"][-1]["content"].strip()
if k in seen and seen[k] != a:
conflicts[k] += 1
seen.setdefault(k, a)
return {"train_examples": len(train), "parse_errors": errs + eval_errs,
"duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
"same_input_different_answer": len(conflicts),
"eval_items_also_in_train": len(leaked),
"answer_distribution": labels.most_common(5),
"examples_with_possible_pii": dict(pii)}
if __name__ == "__main__":
print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))
L’abbiamo eseguito su un file giocattolo di sette righe con ticket di supporto in arabo, inglese e spagnolo. Ha trovato una riga senza risposta dell’assistente, due input duplicati (uno differiva solo per un segno diacritico, che il normalizzatore rimuove, come in normalizzazione del testo arabo), un input etichettato sia billing sia other, un elemento di valutazione presente anche nell’addestramento e un numero di telefono. Ognuno di questi avrebbe fatto sembrare il fine-tune migliore o peggiore di quanto sia.
La normalizzazione conta per l’arabo. Senza, “متأخر” e “متأخِّر” contano come input diversi, e una quasi-copia di un elemento di test può scivolare nell’addestramento.
Come si valuta un fine-tune in modo corretto?
Usa lo stesso test set tenuto da parte che hai usato per il riferimento, e tienilo fuori dall’addestramento. Poi confronta:
- Con il prompt migliore, non con il primo. Un fine-tune che batte un prompt debole non dimostra nulla.
- Per categoria e per lingua. Un guadagno complessivo può nascondere un calo in arabo mentre l’inglese migliora. Riporta ciascuno.
- Sul comportamento generale. Aggiungi da 20 a 50 richieste ordinarie che il modello gestiva bene prima. Un addestramento ristretto può peggiorare il comportamento al di fuori del compito.
- Su costi e latenza. Spesso un fine-tune si giustifica con un modello più piccolo che fa il lavoro. Misura anche token e tempo per richiesta.
Decidi la regola di superamento prima di vedere i numeri, come nell’articolo sulle valutazioni: per esempio, «almeno 5 punti meglio sulle etichette di fatturazione, nessuna categoria peggiore di più di 2 punti, arabo e inglese entrambi superati».
Che cosa cambia se non puoi fare fine-tuning dei modelli ospitati?
Le API ospitate che offrono fine-tuning self-service sono meno di quanto ci si aspetti. La pagina delle deprecazioni di OpenAI registra un aggiornamento alla sua piattaforma di fine-tuning self-service: dal 7 maggio 2026 le organizzazioni che non avevano mai eseguito fine-tuning non possono più creare job; dal 2 luglio 2026 non possono farlo nemmeno le organizzazioni che negli ultimi 60 giorni non avevano eseguito inferenza su un modello ottimizzato; e dal 6 gennaio 2027 anche i clienti esistenti attivi non potranno più creare nuovi job di fine-tuning. I modelli già ottimizzati restano disponibili per l’inferenza finché i loro modelli di base non vengono deprecati.
L’alternativa abituale è un modello open-weight addestrato con un metodo efficiente nei parametri come LoRA. Il paper di LoRA (Hu et al.) riporta che, rispetto al fine-tuning completo di GPT-3 175B con Adam, LoRA può ridurre di 10.000 volte il numero di parametri addestrabili e di 3 volte la memoria GPU necessaria. Poi ti serve un posto dove servire il risultato, cioè il tuo hardware o un provider che ospita pesi personalizzati. Modelli open-weight vs chiusi tratta questo compromesso.
Dove si colloca BroadNet Inference
BroadRouter è il sito di BroadNet. L’API self-service di BroadNet Inference non ha un endpoint di fine-tuning: il suo riferimento API documenta solo chat completions e trascrizione audio. La stessa pagina dice “private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (traduzione: «endpoint privati, i nostri fine-tune per l’arabo e altri modelli su richiesta si raggiungono con un ID privato rilasciato insieme all’endpoint»). Le pagine dei modelli di BroadNet indicano come disponibile su richiesta un fine-tune BroadNet di Cohere Transcribe Arabic per numeri, date e nomi in audio rumoroso, con un ID del modello privato per cliente, e dicono che Gemma 4 VL 26B è disponibile su un endpoint privato “including our Arabic fine-tunes” (traduzione: «compresi i nostri fine-tune per l’arabo»). Sono richieste da fare tramite la pagina dei contatti, non qualcosa che puoi acquistare o addestrare da solo; pianificare un endpoint privato spiega che cosa inviare.
Per tutto ciò che viene prima di quel passo, i modelli pubblici bastano per costruire il set di valutazione e il riferimento: Qwen3.8 27B e GLM 5.3 documentano l’output strutturato, Gemma 4 VL 26B funziona con il credito iniziale di $5 e BroadNet Transcribe Arabic gestisce il parlato a $0.0042 al minuto. Il contenuto dell’inferenza non viene conservato; i metadati necessari di account, fatturazione e sicurezza vengono conservati come descritto nell’informativa sulla privacy di BroadNet.
