Come Fare il Fine-Tuning di un LLM: Metodi, Framework e Codice Passo per Passo [2026]

Il fine-tuning di un LLM significa prendere un modello pre-addestrato e addestrarlo sui tuoi dati specifici in modo che esegua il tuo compito meglio di qualsiasi prompt. La barriera d'ingresso è crollata: QLoRA + Unsloth ora permettono di fare fine-tuning di un modello a 8 miliardi di parametri su una GPU consumer da 12 GB per meno di 1 € in costi cloud.

Questa guida copre l'intero percorso -- quando fare fine-tuning (vs. RAG o prompt engineering), quale metodo e framework scegliere, come preparare il dataset, una guida Llama 3 pronta per il copia-incolla, scenari di costo reali e il deployment.

Il Fine-Tuning in Breve

Prima di impegnarti in qualcosa, ecco il quadro rapido:

Ora scopriamo se il fine-tuning è davvero la scelta giusta per il tuo progetto.

Quando Dovresti Fare il Fine-Tuning di un LLM? (vs. RAG vs. Prompt Engineering)

Questa è la domanda che la maggior parte degli sviluppatori salta -- e gli costa settimane di sforzi sprecati. Il fine-tuning è potente, ma non è sempre lo strumento giusto. Ecco un framework per decidere.

La decisione si riduce a cosa stai cercando di cambiare. Ecco scenari reali:

Se stai scegliendo il giusto stack AI per il tuo SaaS, questo framework decisionale è il primo passo. Molti team costruiscono pipeline RAG complesse quando un fine-tune di 500 esempi darebbe loro risultati più coerenti con latenza inferiore.

Verdetto: Fai il fine-tuning quando hai bisogno che il modello si comporti diversamente, non solo che sappia cose diverse. Se hai solo bisogno di nuove conoscenze, il RAG è più economico e facile da mantenere. Se hai bisogno di entrambe le cose, opta per l'approccio ibrido.

Come Funziona il Fine-Tuning degli LLM? Full vs. LoRA vs. QLoRA

Ci sono tre approcci principali che differiscono notevolmente in termini di requisiti hardware, costi e qualità. Capire i compromessi ti salva dall'over-investire o dall'under-performare.

Fine-Tuning Completo (Quando il Budget Non è un Problema)

Il fine-tuning completo aggiorna ogni parametro nel modello. Produce i migliori risultati possibili ma richiede risorse enormi -- circa 100+ GB di VRAM per un modello 7B (devi memorizzare simultaneamente il modello, gli stati dell'ottimizzatore e i gradienti). Questo è il territorio dei cluster H100. A meno che tu non sia in un laboratorio ben finanziato, salta questo.

LoRA: La Rivoluzione PEFT

LoRA (Low-Rank Adaptation) congela il modello base e aggiunge piccole matrici addestrabili chiamate adapter. Invece di aggiornare direttamente un'enorme matrice di pesi W, LoRA decompone l'aggiornamento in due piccole matrici A e B, dove il rango r è molto più piccolo della dimensione del modello. Il risultato: addestri circa l'1–2% dei parametri originali mantenendo il 98–99% della qualità del fine-tuning completo.

La libreria peft di Hugging Face è l'implementazione standard. Gli adapter LoRA sono tipicamente 50–200 MB -- minuscoli rispetto al modello completo.

QLoRA: Il Fine-Tuning per Tutti

QLoRA va un passo oltre LoRA. Carica il modello base in precisione a 4 bit usando un tipo di dati speciale chiamato NormalFloat4 (NF4), poi applica adapter LoRA sopra. La quantizzazione a 4 bit riduce l'uso della VRAM di un ulteriore ~25% rispetto a LoRA standard, preservando una qualità quasi identica.

Questo è ciò che rende il fine-tuning accessibile. Un modello 7B che richiede 100+ GB per il fine-tuning completo entra in 12 GB con QLoRA.

Verdetto: Per il 90% degli sviluppatori, QLoRA è la scelta giusta. La differenza di qualità rispetto al fine-tuning completo è trascurabile per la maggior parte dei compiti, e il risparmio hardware è enorme. Inizia da lì e scala solo se le tue metriche di valutazione lo richiedono.

Quale Framework di Fine-Tuning Usare nel 2026?

La scelta del framework conta più di quanto la maggior parte delle persone realizzi. Quello giusto fa risparmiare ore di configurazione e accelera significativamente il training. Ecco come si confrontano le quattro opzioni principali.

Ecco la raccomandazione rapida:

• Primo fine-tuning? Usa Unsloth. Training più veloce, configurazione più semplice, notebook Colab gratuiti per iniziare subito.
• Hai bisogno di una UI web senza codice? Usa LLaMA-Factory. La sua GUI LLaMA-Board ti permette di configurare e avviare il training da un browser.
• Stai facendo alignment (RLHF, DPO, GRPO)? Usa TRL. È lo standard Hugging Face per il training basato sulle preferenze, e la v0.15.0 (marzo 2026) ha aggiunto il supporto nativo GRPO.
• Pipeline di produzione su multi-GPU? Usa Axolotl. Le configurazioni basate su YAML rendono gli esperimenti riproducibili e verificabili.

Un trucco utile: Unsloth e LLaMA-Factory possono essere combinati. LLaMA-Factory supporta Unsloth come backend di training, dandoti la comodità della GUI con le ottimizzazioni di velocità di Unsloth.

Come Prepari un Dataset di Fine-Tuning?

La qualità dei dati è il singolo fattore più importante per il successo del fine-tuning. Un dataset ben curato di 500 esempi supererà quasi sempre uno rumoroso di 10.000 esempi.

Formati del Dataset

I due formati dominanti sono chat (compatibile OpenAI) e instruction (stile Alpaca). Ecco come appare ciascuno in formato JSONL:

Formato chat (consigliato per la maggior parte dei casi d'uso):

{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "I ordered a laptop 3 days ago (order #4821) and it still says processing."}, {"role": "assistant", "content": "I can see order #4821 is currently in our warehouse being prepared for shipment. Laptops typically ship within 3-5 business days. You should receive a tracking number by tomorrow. Would you like me to flag this for priority processing?"}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "Can I return my keyboard? Order #3019, bought it last week."}, {"role": "assistant", "content": "Absolutely! Order #3019 is within our 30-day return window. I'll email you a prepaid return label right now. Once we receive the keyboard, your refund will process within 2-3 business days."}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "My monitor arrived cracked. Order #5573."}, {"role": "assistant", "content": "I'm sorry about that! For order #5573, I'm initiating an immediate replacement shipment -- no need to return the damaged unit. The new monitor will ship today with express delivery. You'll get a tracking email within the hour."}]}

Formato instruction (stile Alpaca):

{"instruction": "Summarize the following customer complaint in one sentence.", "input": "I've been waiting 2 weeks for my refund and nobody responds to my emails. This is the worst customer service I've ever experienced.", "output": "Customer is frustrated by a 2-week delay in receiving their refund and lack of email response from support."}
{"instruction": "Classify the sentiment of this review.", "input": "The product works fine but shipping took forever.", "output": "Mixed (positive product, negative shipping)"}

Linee Guida sulla Dimensione del Dataset

Di quanti dati hai effettivamente bisogno? Dipende dalla complessità del compito:

1. 50–100 esempi -- prova di concetto, abbastanza per testare se il fine-tuning aiuta
2. 500–1.000 esempi -- utile per la maggior parte dei compiti singoli (classificazione, estrazione, formattazione)
3. 5.000–10.000 esempi -- risultati di qualità produzione per compiti complessi
4. 10.000+ esempi -- rendimenti decrescenti a meno che il tuo compito abbia un'alta variabilità

Checklist per la Qualità dei Dati

Prima del training, valida il tuo dataset secondo questi criteri:

• Formattazione coerente in tutti gli esempi (stesso prompt di sistema, stessa struttura di output)
• Esempi diversificati che coprono casi limite e modalità di errore
• Nessuna contraddizione (non insegnare al modello a dire sia "sì" che "no" allo stesso pattern di input)
• Distribuzione equilibrata dei tipi di output (per la classificazione, non il 90% degli esempi in una classe)
• Rimuovere voci duplicate o quasi duplicate

Consiglio pro: Usa GPT-4 o Claude per generare dati di training sintetici iniziali, poi raffinali con una revisione umana. 500 esempi sintetici di alta qualità spesso superano 5.000 esempi reali rumorosi. La guida di fine-tuning di Meta raccomanda questo approccio per avviare i dataset.

Passo per Passo: Fine-Tuning di Llama 3 8B con QLoRA e Unsloth

Ecco la guida completa. Ogni blocco di codice è pronto per il copia-incolla -- puoi eseguirlo in un notebook Google Colab gratuito o su qualsiasi macchina con 12+ GB di VRAM.

Passaggio 1: Installare Unsloth

pip install unsloth

È tutto. Unsloth gestisce automaticamente tutte le dipendenze (transformers, peft, trl, bitsandbytes).

Passaggio 2: Caricare il Modello Base a 4 Bit

from unsloth import FastLanguageModel

# Caricare Llama 3.1 8B in quantizzazione a 4 bit
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

Questo scarica il modello quantizzato a 4 bit (~4 GB) e lo carica nella memoria GPU. Su una RTX 3060 (12 GB), avrai ampio spazio per il training.

Passaggio 3: Configurare gli Adapter LoRA

# Aggiungere adapter LoRA al modello
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                # Rango LoRA -- 16 è il punto ottimale per la maggior parte dei compiti
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,       # Fattore di scala (di solito uguale a r)
    lora_dropout=0,      # Unsloth ottimizza per dropout 0
    bias="none",
)

Con r=16, stai addestrando circa 40 milioni di parametri su 8 miliardi -- meno dello 0,5% del modello. Questa è la magia di LoRA.

Passaggio 4: Caricare il Dataset

from datasets import load_dataset

# Caricare il dataset JSONL da Hugging Face Hub o file locale
dataset = load_dataset("json", data_files="train.jsonl", split="train")

# Formattare nel template di chat
def format_chat(example):
    text = tokenizer.apply_chat_template(
        example["messages"],
        tokenize=False,
        add_generation_prompt=False,
    )
    return {"text": text}

dataset = dataset.map(format_chat)

Questo prende il formato di chat JSONL della sezione precedente e applica il template di chat di Llama 3. Il tokenizer gestisce tutti i token speciali (<|begin_of_text|>, <|eot_id|>, ecc.).

Passaggio 5: Configurare e Avviare il Training

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,    # Dimensione batch effettiva = 8
        warmup_steps=5,
        max_steps=60,                     # Regolare in base alla dimensione del dataset
        learning_rate=2e-4,               # Standard per QLoRA
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        output_dir="outputs",
        seed=42,
    ),
)

# Avviare il training
trainer.train()

Iperparametri chiave da capire:

• Learning rate (2e-4): Lo standard per QLoRA. Abbassa (2e-5) se vedi il modello dimenticare capacità generali.
• Batch size (2) x gradient accumulation (4): Dimensione batch effettiva di 8. Aumenta gradient_accumulation se la GPU esaurisce la memoria.
• max_steps (60): Per 500 esempi, questo è circa 1 epoch. Inizia con 1–3 epoch e osserva la loss di validazione.
• Rango r (16): Più basso (4–8) per compiti semplici, più alto (32–64) per compiti complessi. 16 è un valore predefinito sicuro.

Passaggio 6: Salvare e Testare

# Salvare gli adapter LoRA (piccoli -- ~50-200 MB)
model.save_pretrained("my-fine-tuned-model")
tokenizer.save_pretrained("my-fine-tuned-model")

# Test di inferenza rapido
FastLanguageModel.for_inference(model)
inputs = tokenizer(
    [tokenizer.apply_chat_template(
        [{"role": "user", "content": "I need to return order #7742"}],
        tokenize=False,
        add_generation_prompt=True,
    )],
    return_tensors="pt",
).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Questa è l'intera pipeline. Su una RTX 4090 con Unsloth, addestrare 500 esempi richiede circa 15–30 minuti. Su un Colab T4 gratuito, prevedi 1–2 ore.

Cosa Dire del Fine-Tuning via API? (OpenAI, Google, Mistral)

Non tutti vogliono gestire le GPU. I provider di API ti permettono di fare fine-tuning tramite un semplice flusso di caricamento e training. Ecco come si confrontano con il farlo autonomamente.

Quando il fine-tuning via API ha senso: Devi iterare velocemente, il tuo dataset è piccolo, non vuoi gestire l'infrastruttura, o hai specificamente bisogno di un modello chiuso come GPT-4o.

Quando vince il fine-tuning locale: La privacy dei dati è importante (sanità, finanza, legale), esegui il training frequentemente, vuoi possedere ed esportare i pesi, o ottimizzi per il costo su larga scala.

Verdetto: Il fine-tuning via API è il percorso più veloce verso una prova di concetto. Il fine-tuning locale è il percorso più economico verso la produzione. La maggior parte dei team crea prototipi su un'API, poi passa a Unsloth locale una volta validato l'approccio.

Quanto Costa il Fine-Tuning di un LLM?

La narrativa "il fine-tuning è caro" è rimasta bloccata al 2023. Ecco cosa costa realmente oggi.

La curva dei costi si appiattisce rapidamente. Una startup che fa fine-tuning di un modello 8B su RunPod spende meno per il training che per una tazza di caffè. Anche lo scenario di produzione 70B è sotto i 30 € -- questo è il budget pranzo mensile di un junior developer.

Provider di GPU cloud da confrontare: RunPod (migliori prezzi spot), Lambda (H100 on-demand affidabili), Vast.ai (il più economico ma qualità variabile) e Modal (serverless, pagamento al secondo).

Il grafico sopra mostra perché QLoRA ha cambiato le regole del gioco. Un modello 7B che richiedeva un cluster multi-GPU per il fine-tuning completo ora entra in una GPU da laptop. Il modello 70B scende da "solo cloud" a una singola A100.

Verdetto: Puoi fare il fine-tuning di un modello 8B di qualità produzione per meno di 1 €. La barriera dei costi per il fine-tuning è scomparsa. Il costo reale è il tempo di preparazione del dataset.

Come Valuti un Modello con Fine-Tuning?

Il training è solo la metà del lavoro. Senza una valutazione adeguata, non puoi dire se il tuo modello con fine-tuning è effettivamente migliorato -- o se ha semplicemente memorizzato i tuoi dati di training.

Metriche Automatizzate

Tieni traccia di queste durante e dopo il training:

• Loss di training / perplexità: Deve diminuire costantemente, poi stabilizzarsi. Se scende a quasi zero, stai andando in overfitting.
• Metriche specifiche del compito: Accuratezza (classificazione), BLEU/ROUGE (riassunto), corrispondenza esatta (estrazione), F1 (multi-label). Scegli la metrica che corrisponde al tuo compito.

Valutazione Umana

I numeri non catturano tutto. Per compiti generativi:

• Test A/B: Mostra l'output del modello base vs. quello con fine-tuning fianco a fianco. Fai scegliere a 3–5 valutatori la risposta migliore su 50+ esempi. Tieni traccia del tasso di vittorie.
• Valutazione su scala Likert: Valuta gli output su rilevanza (1–5), accuratezza (1–5) e tono (1–5). Calcola il miglioramento medio rispetto al modello base.

Controllo della Dimenticanza Catastrofica

Questo è quello che la maggior parte degli sviluppatori salta. Dopo il fine-tuning, esegui il modello su un benchmark generale come MMLU o HellaSwag. Se i punteggi scendono di più di 2–3 punti, il tuo modello ha perso troppa conoscenza generale. La soluzione: abbassa il learning rate, riduci le epoch, o passa a LoRA (che congela i pesi base).

Regola pratica: Tieni sempre da parte il 10–20% del dataset come test set. Non valutare mai sui dati di training -- non ti dice nulla sulle prestazioni nel mondo reale.

Come Effettui il Deploy di un Modello con Fine-Tuning?

Il training è fatto. Ora devi servirlo. La maggior parte delle guide salta questa parte completamente.

Passaggio 1: Unire gli Adapter LoRA

Se hai usato LoRA o QLoRA, unisci gli adapter nel modello base per l'inferenza:

# Unire gli adapter nel modello base
model.merge_and_unload()
model.save_pretrained("merged-model")
tokenizer.save_pretrained("merged-model")

Passaggio 2: Scegli il Percorso di Deploy

Sviluppo locale e test -- Ollama:

# Convertire al formato GGUF (formato nativo di Ollama)
python llama.cpp/convert_hf_to_gguf.py merged-model --outfile model.gguf --outtype q4_k_m

# Creare un modello Ollama
ollama create my-fine-tuned-model -f Modelfile
ollama run my-fine-tuned-model

Serving in produzione -- vLLM:

# Avviare un server API compatibile OpenAI
python -m vllm.entrypoints.openai.api_server \
    --model merged-model \
    --host 0.0.0.0 \
    --port 8000

Serverless (zero infrastruttura): Carica il modello su Together AI, Fireworks o Modal. Ottieni un endpoint API senza gestire server. Il costo scala con l'utilizzo.

Avanzato: Serving Multi-Adapter

Ecco un pattern che più team dovrebbero usare: tenere un modello base caricato in memoria e scambiare gli adapter LoRA per richiesta. Potresti servire un adapter di supporto clienti, un adapter di revisione del codice e un adapter di riassunto -- tutti da una singola GPU. vLLM lo supporta nativamente con il flag --enable-lora.

Quali Sono gli Errori di Fine-Tuning Più Comuni?

Dopo aver aiutato team a fare il debug di decine di run di fine-tuning, questi sono gli errori che si ripresentano continuamente.

1. Overfitting su dataset piccoli. Addestri per 10 epoch su 200 esempi, la loss di training scende a quasi zero e il modello ripete i tuoi dati di training parola per parola. Soluzione: massimo 1–3 epoch, usa un validation set e monitora il divario tra training loss e eval loss.

2. Dimenticanza catastrofica. Il modello eccelle nel tuo compito specifico ma non riesce più a sostenere una conversazione di base. Soluzione: usa LoRA/QLoRA (congela i pesi base), mantieni i learning rate bassi (2e-5 per il fine-tuning completo, 2e-4 per QLoRA) e valuta su benchmark generali prima del deploy.

3. Qualità dei dati scadente. Formattazione inconsistente, contraddizioni tra esempi o duplicati. Il modello impara il rumore. Soluzione: pulisci i tuoi dati prima del training. Sempre. Dedica più tempo alla cura dei dati che al tuning degli iperparametri.

4. Iniziare con un modello troppo grande. I team saltano direttamente al 70B perché "più grande è meglio", poi non possono permettersi i costi della GPU. Soluzione: inizia con 8B. Se 8B con buoni dati non riesce a risolvere il tuo compito, 70B con gli stessi dati probabilmente non ci riuscirà neanche. Prima scala la qualità dei dati, poi la dimensione del modello.

5. Nessuna pipeline di valutazione. Training senza un test set riservato, poi deploy basato sull'intuizione. Soluzione: dividi i dati 80/10/10 (train/val/test) prima di iniziare. Confronta con il modello base su ogni esempio di test.

6. Learning rate troppo alto. Distrugge la conoscenza pre-addestrata nei primi passaggi. Il modello produce output incomprensibili. Soluzione: inizia a 2e-4 per QLoRA, 2e-5 per il fine-tuning completo. Se gli output peggiorano, abbassa ancora.

Come Techsy Affronta il Fine-Tuning degli LLM

In Techsy, seguiamo un percorso di escalation rigoroso per ogni progetto AI: prima il prompt engineering, secondo il RAG, il fine-tuning solo quando i dati dimostrano che è necessario. La maggior parte dei progetti clienti non richiede effettivamente il fine-tuning -- prompt ben progettati o una pipeline RAG risolvono il problema con costi e complessità inferiori.

Quando il fine-tuning è la scelta giusta, ecco il nostro processo:

1. Audit del dataset -- Esaminiamo i dati del cliente per qualità, copertura e formattazione. Se non abbiamo abbastanza esempi, aiutiamo a costruire un dataset sintetico usando GPT-4 o Claude con revisione umana.
2. Selezione del framework -- Unsloth + QLoRA per il 90% dei progetti startup. Axolotl per i clienti che necessitano di pipeline di produzione riproducibili su multi-GPU.
3. Training e valutazione -- Addestriamo sempre con un test set riservato e facciamo benchmark contro il modello base. Se il modello con fine-tuning non migliora misurabilmente la metrica obiettivo, non lo deployiamo.
4. Deploy -- vLLM per il serving in produzione, pattern multi-adapter quando i clienti necessitano di più modelli specializzati da una singola GPU.

Abbiamo consegnato modelli con fine-tuning per startup che non potevano permettersi budget GPU enterprise -- QLoRA su RunPod mantiene i costi sotto i 30 € anche per i modelli 70B.

Hai bisogno di aiuto per fare il fine-tuning di un LLM per il tuo caso d'uso? Aiutiamo i team a passare dai dati grezzi al modello deployato. Ottieni una consulenza gratuita

Domande Frequenti sul Fine-Tuning degli LLM

Cos'è il fine-tuning degli LLM?

Il fine-tuning degli LLM è il processo di addestrare un modello linguistico pre-addestrato sui propri dati specifici per un compito in modo che esegua meglio quel compito. In sostanza stai insegnando al modello nuovi comportamenti, formati o competenze del dominio che il prompting generico non riesce a raggiungere in modo affidabile.

Quando dovrei fare fine-tuning invece di usare RAG?

Fai fine-tuning quando hai bisogno che il modello si comporti diversamente -- formato di output coerente, linguaggio specifico del dominio, tono particolare. Usa il RAG quando il modello deve sapere cose diverse, specialmente se quella conoscenza cambia frequentemente. Per molti sistemi in produzione, un approccio ibrido funziona meglio.

Quanto costa il fine-tuning di un LLM?

Da 0 € a 540 € a seconda della scala. La maggior parte degli sviluppatori individuali spende meno di 1 € usando QLoRA su un RunPod RTX 4090 (0,34 $/h). Un modello di produzione 70B su un A100 costa 17–27 €. Il fine-tuning completo su cluster H100 costa 270–540 €. Il fine-tuning via API (OpenAI) costa 3–25 € per 1.000 esempi.

Posso fare il fine-tuning di un LLM sul mio laptop?

Sì, se il tuo laptop ha una GPU con 12+ GB di VRAM. Una GPU laptop RTX 3060 gestisce modelli 8B con QLoRA. I Mac con Apple Silicon con 16+ GB di memoria unificata possono anche fare fine-tuning via MLX, anche se è più lento di CUDA. Per modelli più grandi, avrai bisogno di GPU cloud.

Qual è la differenza tra LoRA e QLoRA?

Entrambi aggiungono piccoli layer di adapter addestrabili mentre congelano il modello base. La differenza: QLoRA quantizza anche il modello base a precisione 4 bit (tipo di dati NF4), riducendo l'uso della VRAM di ~25% rispetto a LoRA standard. La qualità è quasi identica -- QLoRA raggiunge il 97–99% della qualità del fine-tuning completo.

Di quanti esempi di training ho bisogno?

Dipende dalla complessità del compito. 50–100 esempi sono sufficienti per una prova di concetto. 500–1.000 esempi producono risultati utili per la maggior parte dei compiti singoli. 5.000–10.000 esempi offrono qualità di produzione per compiti complessi. Oltre 10.000, si raggiungono rendimenti decrescenti a meno che il compito non abbia una variabilità estremamente alta.

Quale modello base fare il fine-tuning nel 2026?

Llama 3.x per compiti di uso generale (miglior rapporto qualità/dimensione). Mistral per le lingue europee e l'inferenza efficiente. Qwen 2.5 per compiti multilingua e di codice. Phi-4 quando hai bisogno della footprint più piccola possibile. Gemma 2 per l'integrazione nell'ecosistema Google.

Cos'è GRPO e perché è importante?

GRPO (Group Relative Policy Optimization), introdotto da DeepSeek, è un successore di RLHF per il training di allineamento. Il vantaggio principale: non richiede di addestrare un modello di ricompensa separato, il che taglia il costo computazionale di circa la metà. TRL v0.15.0 supporta GRPO nativamente, rendendolo accessibile a chiunque utilizzi l'ecosistema Hugging Face.

Come prevengo la dimenticanza catastrofica?

Usa LoRA o QLoRA invece del fine-tuning completo -- congelano i pesi del modello base, preservando la conoscenza generale. Mantieni il learning rate basso (2e-4 per QLoRA, 2e-5 per il completo). Addestra per il minor numero di epoch necessario (1–3 è di solito sufficiente). Dopo il training, esegui il modello su benchmark generali (MMLU, HellaSwag) per verificare che non sia regredito.

Posso combinare fine-tuning e RAG?

Assolutamente, e molti sistemi in produzione fanno esattamente questo. Fai fine-tuning per la coerenza del comportamento e del formato, poi connetti il RAG per il recupero di conoscenze aggiornate. Il modello con fine-tuning è migliore nell'utilizzo del contesto recuperato perché capisce il linguaggio e i requisiti di output del tuo dominio.

Quanto tempo richiede il fine-tuning?

Per la maggior parte dei progetti, da 30 minuti a 8 ore. Un modello 8B con 500 esempi su Unsloth + RTX 4090 finisce in 15–30 minuti. Lo stesso job su un Colab T4 gratuito richiede 1–2 ore. I modelli 70B su A100 richiedono 5–8 ore. Il fine-tuning completo su configurazioni multi-GPU può richiedere 20–40 ore.

Vale la pena l'API di fine-tuning di OpenAI?

Per la prototipazione rapida, sì. Puoi caricare un file JSONL e avere un GPT-4o-mini con fine-tuning in 30 minuti senza configurazione GPU. Per la produzione, il fine-tuning locale è di solito meglio: possiedi i pesi, controlli la privacy dei dati e i costi sono inferiori su larga scala. La maggior parte dei team inizia con l'API per validare l'approccio, poi migra al locale.

Conclusione

Fare il fine-tuning di un LLM non è più la magia nera che era due anni fa. Ecco i punti chiave:

1. Inizia con QLoRA + Unsloth -- copre il 90% dei casi d'uso su hardware consumer
2. I buoni dati battono un modello più grande ogni volta. Dedica il tuo impegno alla qualità del dataset, non agli upgrade della GPU.
3. La barriera dei costi è scomparsa -- fai fine-tuning di un modello 8B per meno di 1 € su GPU cloud
4. Valuta sempre rispetto al modello base prima del deploy. Se non è misurabilmente migliore, non rilasciarlo.
5. Considera prima il RAG -- fai fine-tuning solo quando hai bisogno che il modello si comporti diversamente, non solo che sappia cose diverse

Pronto per l'implementazione? Consulta i nostri Best LLM Fine-Tuning Tools & Platforms [in arrivo] per un confronto dettagliato dei framework di training e delle opzioni di deploy.

Se hai trovato utile questa guida, dai un'occhiata alla nostra guida su come scegliere il giusto stack AI per le decisioni architetturali più ampie sui prodotti basati su AI.

Fonti

• Repository GitHub di Unsloth -- framework di fine-tuning con miglioramenti di velocità 2–5x
• Documentazione TRL di Hugging Face -- SFTTrainer, DPO e implementazione GRPO
• Documentazione PEFT di Hugging Face -- LoRA e fine-tuning parameter-efficient
• Paper QLoRA (Dettmers et al., 2023) -- ricerca sulla quantizzazione NormalFloat a 4 bit
• Paper LoRA (Hu et al., 2021) -- adattamento a basso rango dei grandi modelli linguistici
• Documentazione API Fine-Tuning OpenAI -- flusso di lavoro di fine-tuning via API
• Prezzi GPU Cloud RunPod -- riferimento costi GPU cloud
• Documentazione vLLM -- serving LLM in produzione
• Guida Fine-Tuning Llama di Meta -- raccomandazioni ufficiali di training Llama
• Paper DeepSeekMath (GRPO) -- Group Relative Policy Optimization