Fine-tuning: adattare un modello ai tuoi dati con LoRA e QLoRA

Il fine-tuning è il passaggio successivo quando i prompt e il RAG non bastano: adatti i pesi di un modello ai tuoi dati, e il modello impara il tuo formato, il tuo tono e le tue regole. Non serve un data center: con LoRA e QLoRA un modello 7B si adatta su una singola GPU consumer, e lo strumento giusto ti fa partire con un file di configurazione, non con un codice da scrivere da zero.

Quando serve davvero (e quando no)

La prima regola: non fare fine-tuning per memoria. Se vuoi che il modello conosca i tuoi documenti, la risposta giusta è il RAG: aggiungi un indice di documenti e il modello li consulta a ogni risposta. Il fine-tuning cambia invece il comportamento base del modello: il formato di output, il registro linguistico, lo stile delle risposte, le convenzioni del tuo dominio.

Una buona prova è questa: se puoi spiegare quello che vuoi al modello con un prompt (o con un esempio nel prompt), fermati lì. Il prompt è gratis, reversibile e si modifica in un minuto. Se invece la stessa istruzione la stai ripetendo in ogni richiesta da mesi, il fine-tuning ti fa risparmiare tempo a ogni conversazione.

Un terzo caso, spesso sottovalutato: ridurre i token di contesto. Un modello adattato al tuo formato di output risponde con messaggi più brevi, perché ha imparato lo schema una volta sola invece di rileggerlo in ogni prompt.

Come funziona: LoRA e QLoRA in parole semplici

Un modello 7B ha circa 7 miliardi di parametri. Riallevarli tutti sui tuoi dati costa decine di GB di VRAM e ore di calcolo. LoRA (Low-Rank Adaptation), la tecnica descritta nel paper del 2021, aggira il problema: i pesi originali restano congelati, e accanto a ogni layer importante si inserisce una piccola matrice aggiuntiva (l'adattatore) che è quella che viene addestrata. Alla fine il risultato è un file di pochi MB, non un modello da decine di gigabyte.

I numeri del paper: con una matrice di rango 8, il parametro addestrabile scende fino a un millesimo di quello del modello completo, senza perdita misurabile sulla qualità. E il rango (r) è la manopola principale: r=8-16 per la maggior parte dei casi, valori più alti solo quando i dati lo richiedono.

QLoRA (2023) spinge oltre: quantizza il modello base a 4 bit (formato NF4) prima dell'addestramento, in modo che un modello da 65B stia dentro una singola GPU da 48 GB. In pratica significa che il confine tra "modelli adattabili" e "modelli irraggiungibili" si è spostato di una generazione di hardware.

Il vantaggio pratico più importante: l'adattatore è un file separato. Puoi tenervi tre adattatori (tono formale, output JSON, sintesi breve) sul stesso modello base e caricare quello che serve. Stesso peso base, tre comportamenti.

Preparare i dati: il 90% del lavoro

Lo strumento conta, i dati contano di più. Tre consigli che fanno la differenza:

Formato. Il formato più diffuso e supportato da tutti gli strumenti è il file JSONL: una riga per esempio, con i campi di conversazione. Per LLaMA-Factory il formato alpaca (prompt, istruzione, output) è quello che userai nel 90% dei casi.

Quantità. Non servono migliaia di esempi: per un formato di output ben definito, 100-500 esempi di qualità battono 10.000 generati al volo. La qualità della etichetta (la risposta che insegni) conta più della quantità.

Coerenza. Se vuoi un output in JSON, tutti gli esempi devono essere JSON valido. Se mescoli tre formati, il modello impara la media, cioè il disordine.

Un errore classico: addestrare con dati che il modello sa già fare. Se il modello risponde già bene senza adattatore, stai spendendo tempo e VRAM per zero guadagno. Fai prima un test con prompt e guarda dove sbaglia davvero.

Strumenti locali per fare fine-tuning

LLaMA-Factory è lo standard de facto per chi fa fine-tuning in locale: un solo framework per 100+ modelli (Qwen, Llama, Mistral, Gemma), metodi da SFT completo a LoRA/QLoRA e DPO, interfaccia web integrata (WebUI) e avvio con un file YAML. È il progetto di fine-tuning più usato nella community, con oltre 75.000 star su GitHub (repo).

Un esempio concreto: per adattare Qwen su una RTX 4090 con QLoRA, il file di configurazione contiene il modello base, il dataset (il tuo JSONL, registrato in dataset_info.json), il metodo LoRA con il rango e i layer da adattare, e i parametri di addestramento. Poi un comando e la WebUI ti mostra loss e curva di addestramento.

Unsloth è l'alternativa che punta sulla velocità: ottimizzazioni che riducono l'uso di memoria e aumentano la velocità di addestramento (il progetto dichiara velocità fino a 2x e memoria dimezzata rispetto ai metodi standard), con supporto per GPU NVIDIA e per Apple Silicon (repo). Se la tua GPU va sul limite, è spesso la via più corta.

MLX è la via Apple Silicon: il framework di machine learning di Apple per il chip, con la libreria mlx-lm che supporta addestramento e fine-tuning di LLM direttamente su Mac, con la memoria unificata a favore (repo). Su M3/M4/M5 da 32-64 GB un fine-tuning LoRA di un modello 7B è una serata, non un progetto.

Quanta hardware ci vuole?

Regola pratica per un modello 7B:

• QLoRA (4 bit): 8-12 GB di VRAM. Una RTX 3060 12GB o un Mac con 16-32 GB ci fa.
• LoRA full precision: 16-24 GB. RTX 4090 o RTX 3090.
• Modello 13-14B in QLoRA: 16-24 GB.
• Modello 70B in QLoRA: 48 GB+ (RTX A100 48GB, o Mac da 128+ GB).

Il contesto di addestramento pesa più di quanto pensi: 2048 token di contesto in più raddoppiano quasi l'uso di memoria. Parti con 1024 se i tuoi esempi sono brevi.

I limiti pratici

Sii onesto su cosa il fine-tuning non può fare:

1. Non aggiunge conoscenze fattuali stabili. Se insegni un fatto, il modello lo "impara" in modo fragile: lo dice oggi, lo dimentica o lo contraddice tra dieci esempi. Per la conoscenza, RAG. Per il comportamento, fine-tuning.
2. Dimentica qualcosa del modello base. Il fenomeno si chiama catastrophic forgetting: più addestri, più il modello si allontana dal comportamento generale. I dati di "riempimento" (esempi generici misti a quelli tuoi) lo mitigano.
3. Serve una metrica. Senza un set di test con risposte corrette, non sai se stai migliorando o peggiorando. Tienine da parte 50-100 esempi che non usi nell'addestramento e confronta le risposte prima/dopo.
4. Il modello base cambia, l'adattatore no. Se passi da una versione del modello alla successiva, l'adattatore va rifatto. Budgeta un'ora di verifica a ogni aggiornamento.

In sintesi

• Prompt/RAG prima, fine-tuning quando il comportamento ripetuto non regge.
• 100-500 esempi di qualità, formato coerente, etichette curate.
• LLaMA-Factory per partire, Unsloth se la VRAM è stretta, MLX su Mac.
• QLoRA è la porta d'ingresso: 4 bit, adattatore da pochi MB, una GPU consumer.
• Misura sempre prima/dopo, e ricorda: la conoscenza va nel RAG, il comportamento nel fine-tuning.

Riferimenti

• LoRA: Low-Rank Adaptation of Large Language Models (arXiv 2106.09685) — il paper originale che descrive la tecnica.
• QLoRA: Efficient Finetuning of Quantized LLMs (arXiv 2305.14314) — quantizzazione a 4 bit + LoRA, fine-tuning di 65B su una GPU.
• LLaMA-Factory (GitHub) — framework di fine-tuning unificato, 100+ modelli.
• Unsloth (GitHub) — fine-tuning ottimizzato, NVIDIA e Apple Silicon.
• MLX (GitHub) — framework Apple Silicon con mlx-lm per il fine-tuning di LLM.

Articolo generato con IA