LLM fine‑tuning con LoRA in 12 step: guida completa 2026

Perché il fine‑tuning è tornato di moda nell’estate 2026

Due anni fa il fine‑tuning era considerato troppo costoso e rischioso per la maggior parte dei team: i modelli erano chiusi o, se aperti, decisamente indietro rispetto alle offerte commerciali. Dal 5 agosto 2026, quando Google DeepMind ha rilasciato Gemma 3 sotto licenza Apache 2.0, e dal 12 agosto quando Meta ha pubblicato i pesi di Llama 4, la situazione è cambiata radicalmente. Ora è possibile eseguire il fine‑tuning su una singola GPU consumer, senza dover ricorrere a cluster di data‑center.

Il nuovo impulso è stato alimentato da tre fattori principali:

• Modelli di ultima generazione: Qwen ha introdotto il modello Qwen3.8‑27B con 262 000 token di contesto e capacità multimodale; Mistral AI ha lanciato Shieldstral‑1.0‑3B, un modello compatto per la moderazione dei contenuti direttamente sul dispositivo; Mistral Large 4 ha esteso il contesto a 1 milione di token.
• Hardware più potente e accessibile: QLoRA utilizza la quantizzazione a 4 bit e addestra solo piccole matrici di adattamento, consentendo a modelli da 7 a 8 miliardi di parametri di stare su una RTX 4090 da 24 GB VRAM.
• Maturazione degli strumenti: Hugging Face ha integrato Transformers, PEFT e TRL in pacchetti facili da usare; Unsloth promette un training 2× più veloce e con il 70 % di VRAM in meno, senza perdita di accuratezza.

Secondo TrendX Insights, il mercato del fine‑tuning per IA crescerà a un CAGR del 23,4 % fino al 2034, grazie proprio a queste riduzioni di costo e complessità.

Quando conviene il fine‑tuning rispetto a RAG e prompt engineering

Non tutti i problemi richiedono il fine‑tuning. Se serve solo aggiornare i fatti, la strategia RAG (retrieval‑augmented generation) è più efficace; se basta modificare il tono, un buon system‑prompt può bastare. Il fine‑tuning è consigliato quando:

• il modello deve produrre costantemente un formato fisso (es. risposta in JSON),
• è necessario un stile di scrittura stabile (es. tono amichevole e conciso per un bot di supporto),
• si vuole incorporare conoscenza di dominio che non può essere inserita dinamicamente tramite contesto.

Un caso tipico: un team di supporto vuole che il bot categorizzi i ticket secondo uno schema interno e mantenga un tono uniforme. Con il solo prompt engineering i risultati variano non appena le richieste si discostano leggermente dal modello previsto. Un adattatore LoRA, allenato su qualche centinaio di esempi reali, fissa il comportamento in modo permanente, mantenendo intatto il modello di base.

Confronto sintetico

Kriterio	Prompt Engineering	RAG	Fine‑tuning (LoRA)
Tempo di configurazione	Minuti	Ore‑giorni	Giorni‑settimane
Hardware richiesto	Nessuno	Vettore DB + GPU (12‑48 GB)	GPU 12‑24 GB (per modelli < 8 B)
Cambia comportamento modello	No	Limitato	Sì, permanente
Aggiorna fatti	Limitato	Molto buono	Scarso senza retraining
Adatta tono/formato	Limitato	Scarso	Eccellente
Reversibilità	Immediata	Immediata	Rimuovibile (adapter)
Uso tipico	Prototipi rapidi	Bot con knowledge base aggiornata	Stile fisso, dominio specialistico, output strutturato

Molti team combinano tutti e tre gli approcci: RAG per i fatti recenti, LoRA per tono e struttura, e un system‑prompt per orchestrare il tutto.

Prerequisiti: hardware, software e modello di base

Per il fine‑tuning con QLoRA non serve un data‑center. Una singola GPU con 16 GB VRAM è sufficiente per i modelli più piccoli. L’ambiente consigliato è:

• OS: Ubuntu 24.04 o Windows 11 con WSL2
• Python 3.11
• GPU NVIDIA con driver CUDA aggiornato
• RAM: almeno 32 GB
• Biblioteche: transformers, peft, trl, bitsandbytes, accelerate, datasets (ultime versioni)

Di seguito la tabella dei modelli aperti consigliati per LoRA/QLoRA, con parametri, licenza e requisito minimo di VRAM.

Modello	Parametri	Licenza	Release	VRAM minimo (QLoRA)
Gemma 3 7B	7 B, denso	Apache 2.0	5 ago 2026	16‑24 GB
Gemma 3 27B	27 B, denso	Apache 2.0	5 ago 2026	24‑32 GB
Llama 4 (variante densa)	~8 B, denso	Meta‑License (fine‑tuning commerciale consentito)	12 ago 2026	16‑24 GB
Llama 4 Maverick (MoE)	400 B totale / 17 B attivo	Meta‑License	12 ago 2026	Multi‑GPU
Qwen3.8‑27B	27 B, denso	Apache 2.0	8 ago 2026	≈24 GB (Q4KM ≈17 GB)
Qwen 3.6‑35B‑A3B (MoE)	35 B totale / 3 B attivo	Apache 2.0	2026	24‑48 GB
Mistral Shieldstral‑1.0‑3B	3 B, denso	Apache 2.0	4 ago 2026	8‑12 GB

Per il tutorial useremo Gemma 3 7B, perché è sotto Apache 2.0, richiede solo 24 GB VRAM e supera Llama 4 8B nei benchmark MMLU‑Pro (81,2 % vs 79,8 %), HumanEval (72,5 % vs 68,3 %) e MATH (58,7 % vs 52,1 %).

Passo 1 – Preparare l’ambiente

Creare un nuovo environment Python e installare le dipendenze:

python -m venv lora-env
source lora-env/bin/activate   # Linux/macOS
.\lora-env\Scripts\activate    # Windows
pip install --upgrade pip
pip install transformers peft trl bitsandbytes accelerate datasets

Verificare che CUDA sia riconosciuto:

python -c "import torch; print(torch.cuda.is_available())"

Se il risultato è True, si può procedere.

Passo 2 – Scaricare il modello di base

Utilizzare la hub di Hugging Face per scaricare Gemma 3 7B in versione quantizzata a 4 bit (Q4KM):

from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "google/gemma-3-7b"
tokenizer = AutoTokenizer.frompretrained(modelid)
model = AutoModelForCausalLM.from_pretrained(
model_id,
loadin4bit=True,
device_map="auto"
)

La quantizzazione riduce il consumo di VRAM a circa 16 GB, lasciando spazio per gli adapter LoRA.

Passo 3 – Preparare il dataset

Il dataset deve contenere coppie prompt‑response rappresentative del nuovo stile. Per il caso del support‑bot, un CSV con tre colonne è sufficiente: ticketid, testoticket, risposta_formattata. Caricare con la libreria datasets:

from datasets import load_dataset
data = loaddataset("csv", datafiles="support_dataset.csv")
def format_example(example):
return {
"text": f"Ticket: {example['testoticket']}\nRisposta: {example['rispostaformattata']}"
}
traindata = data["train"].map(formatexample, removecolumns=data["train"].columnnames)

Per un training rapido, limitare a 500‑1000 esempi; per risultati più robusti, aumentare a 5 000‑10 000.

Passo 4 – Configurare LoRA/QLoRA

Importare PEFT e definire i parametri di LoRA:

from peft import LoraConfig, getpeftmodel
lora_config = LoraConfig(
r=16,                # rank
lora_alpha=32,
targetmodules=["qproj", "v_proj"],   # dipende dall’architettura
lora_dropout=0.05,
bias="none",
tasktype="CAUSALLM"
)
model = getpeftmodel(model, lora_config)
model.printtrainableparameters()

Il comando stampa il numero di parametri addestrabili (di solito qualche centinaio di migliaia), confermando la leggerezza dell’adapter.

Passo 5 – Definire il trainer

Usare transformers.Trainer o la più recente classe di TRL (SFTTrainer) per il supervised fine‑tuning:

from trl import SFTTrainer
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
traindataset=traindata,
maxseqlength=1024,
perdevicetrainbatchsize=4,
gradientaccumulationsteps=4,
learning_rate=2e-4,
numtrainepochs=3,
fp16=True,
logging_steps=10,
outputdir="./loragemma7b"
)

Le impostazioni di batch e grad‑accumulation mantengono il consumo di VRAM sotto controllo.

Passo 6 – Avviare il training (≈ 60 min)

Eseguire il trainer:

trainer.train()
trainer.savemodel("./loragemma7b_adapter")

Il tempo di training dipende dal numero di esempi e dalla GPU, ma per 1 000 esempi su una RTX 4090 il processo richiede circa un’ora. Il modello base rimane intatto; viene salvato solo l’adapter LoRA.

Passo 7 – Quantizzare il modello fine‑tuned (opzionale)

Per l’inferenza su dispositivi con meno VRAM, è possibile ricompattare il modello con bitsandbytes in modalità 4‑bit:

from transformers import BitsAndBytesConfig
quant_config = BitsAndBytesConfig(
loadin4bit=True,
bnb4bitcompute_dtype=torch.float16,
bnb4bitusedoublequant=True,
bnb4bitquant_type="nf4"
)
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantizationconfig=quantconfig,
device_map="auto"
)
model = getpeftmodel(model, lora_config)   # ricarica l’adapter
model.savepretrained("./loragemma7b_quant")

Il risultato occupa circa 12 GB, ideale per Ollama o LM Studio.

Passo 8 – Testare il modello locale

Eseguire una generazione di prova:

from transformers import pipeline
pipe = pipeline("text-generation", model="./loragemma7bquant", tokenizer=tokenizer, device=0)
prompt = "Ticket: L’utente segnala un errore di login. Come devo rispondere?"
print(pipe(prompt, maxnewtokens=150, dosample=False)[0]["generatedtext"])

Il risultato dovrebbe rispettare il tono e il formato appreso durante il training.

Passo 9 – Esportare per Ollama

Ollama accetta modelli in formato GGUF. Convertire con llama.cpp:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make quantize
./quantize ./loragemma7bquant/adapter.bin ./gemma7blora.gguf q40

Copiare il file gemma7b_lora.gguf nella cartella di Ollama e registrarlo:

ollama create gemma7b-lora -f ./gemma7b_lora.gguf

Passo 10 – Deploy su LM Studio

In LM Studio selezionare “Importa modello”, puntare alla directory ./loragemma7bquant e attivare la modalità “LoRA”. Il modello sarà immediatamente disponibile per chat interattive o API locali.

Passo 11 – Monitorare e aggiornare l’adapter

Poiché l’adapter è indipendente, è possibile aggiungere nuovi dati e ri‑addestrare solo la parte LoRA senza toccare il modello base. Basta creare un nuovo dataset di aggiornamento e lanciare trainer.train() con model.load_adapter(...) per continuare il training.

Passo 12 – Best practice e consigli finali

• Validazione continua: utilizza un set di validazione separato per verificare che lo stile rimanga coerente.
• Versionamento: salva ogni versione dell’adapter con un tag semantico (es. v1.0‑support).
• Privacy dei dati: anonimizza sempre i ticket prima di includerli nel training.
• Rollback rapido: tenere il modello base intatto permette di rimuovere l’adapter in caso di regressioni.
• Scalabilità: se il dataset supera 50 k esempi, considera l’uso di accelerate con più GPU o di un servizio cloud temporaneo.

Con questi 12 passaggi, anche un piccolo team può creare, quantizzare e distribuire un modello linguistico